@meimu/mutracer 0.2.0 → 0.3.0

package/lib/renderer/wgsl/chunks/background.wgsl.js

@@ -0,0 +1,102 @@
+export default /* wgsl */ `fn di(point: vec3f, height: f32, radius: f32) -> f32 {
+let fQ = length(point);
+if (fQ < 0.00001) {
+return -radius;
+}
+
+let iG = radius * point.y / fQ;
+let iq = -1.5 * height;
+var eq: f32;
+if (iG >= 0.0) {
+eq = radius;
+}
+else if (iG < iq) {
+eq = -height * fQ / point.y;
+}
+else {
+let cv = 1.0
+- iG * iG / (3.0 * iq * iq);
+eq = radius * cv;
+}
+return fQ - eq;
+}
+
+fn eM(origin: vec3f, direction: vec3f) -> vec3f {
+if (!USE_GROUNDED_BACKGROUND) {
+return direction;
+}
+let params = rtUniform.groundedBackgroundParams;
+let bS = normalize(direction);
+let center = vec3f(
+rtUniform.groundedBackgroundCenter.x,
+params.z + params.x,
+rtUniform.groundedBackgroundCenter.y
+);
+let bs = origin - center;
+let eE = dot(bs, bS);
+let bj = eE * eE
+- dot(bs, bs) + params.y * params.y;
+if (
+bj <= 0.0
+|| di(bs, params.x, params.y) > 0.0
+) {
+return direction;
+}
+
+var cw = -eE + sqrt(bj);
+if (cw <= 0.0) {
+return direction;
+}
+
+let oA = bs + bS * cw;
+if (oA.y >= 0.0) {
+return normalize(oA);
+}
+
+if (bS.y < -0.00001 && params.y > 1.5 * params.x) {
+let hP = (-params.x - bs.y) / bS.y;
+let ot = bs + bS * hP;
+let oT = (2.0 / 3.0)
+* sqrt(params.y * params.y - 2.25 * params.x * params.x);
+if (hP > 0.0 && length(ot.xz) <= oT) {
+return normalize(ot);
+}
+}
+
+var cI = 0.0;
+for (var i = 0; i < 14; i++) {
+let fd = (cI + cw) * 0.5;
+let qq = bs + bS * fd;
+if (di(qq, params.x, params.y) > 0.0) {
+cw = fd;
+}
+else {
+cI = fd;
+}
+}
+let hit = bs + bS * ((cI + cw) * 0.5);
+return normalize(hit);
+}
+
+fn ft(ray: Ray) -> vec4f {
+var bg = vec4f(0.0);
+if (USE_BACKGROUND_MAP) {
+let d = eM(ray.o, ray.d);
+let t = rtUniform.backgroundMapTransform;
+let qS = vec3f(t.x * d.x - t.y * d.z, d.y, t.y * d.x + t.x * d.z);
+let rotation = rtUniform.backgroundMapRotation;
+let gU = transpose(mat3x3f(rotation[0].xyz, rotation[1].xyz, rotation[2].xyz)) * qS;
+let aW = textureLinear(backgroundMap, eF(gU));
+bg = vec4f(aW.rgb * t.z, aW.a);
+}
+else if (USE_BACKGROUND) {
+bg = rtUniform.backgroundColor;
+}
+else if (USE_ENVMAP) {
+bg = textureLinear(envMap, cT(ray.d));
+}
+return bg;
+}
+
+`;
+//# sourceMappingURL=background.wgsl.js.map

package/lib/renderer/wgsl/chunks/background.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"background.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/background.wgsl.ts"],"names":[],"mappings":"AAAA,eAAe,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoGzB,CAAC","sourcesContent":["export default /* wgsl */ `fn groundedSurfaceDistance(point: vec3f, height: f32, radius: f32) -> f32 {\n  let pointLength = length(point);\n  if (pointLength < 0.00001) {\n    return -radius;\n  }\n\n  let originalY = radius * point.y / pointLength;\n  let transitionY = -1.5 * height;\n  var surfaceRadius: f32;\n  if (originalY >= 0.0) {\n    surfaceRadius = radius;\n  }\n  else if (originalY < transitionY) {\n    surfaceRadius = -height * pointLength / point.y;\n  }\n  else {\n    let factor = 1.0\n      - originalY * originalY / (3.0 * transitionY * transitionY);\n    surfaceRadius = radius * factor;\n  }\n  return pointLength - surfaceRadius;\n}\n\nfn groundedBackgroundDirection(origin: vec3f, direction: vec3f) -> vec3f {\n  if (!USE_GROUNDED_BACKGROUND) {\n    return direction;\n  }\n  let params = rtUniform.groundedBackgroundParams;\n  let rayDirection = normalize(direction);\n  let center = vec3f(\n    rtUniform.groundedBackgroundCenter.x,\n    params.z + params.x,\n    rtUniform.groundedBackgroundCenter.y\n  );\n  let localOrigin = origin - center;\n  let projectedOrigin = dot(localOrigin, rayDirection);\n  let discriminant = projectedOrigin * projectedOrigin\n    - dot(localOrigin, localOrigin) + params.y * params.y;\n  if (\n    discriminant <= 0.0\n    || groundedSurfaceDistance(localOrigin, params.x, params.y) > 0.0\n  ) {\n    return direction;\n  }\n\n  var farDistance = -projectedOrigin + sqrt(discriminant);\n  if (farDistance <= 0.0) {\n    return direction;\n  }\n\n  let sphereHit = localOrigin + rayDirection * farDistance;\n  if (sphereHit.y >= 0.0) {\n    return normalize(sphereHit);\n  }\n\n  if (rayDirection.y < -0.00001 && params.y > 1.5 * params.x) {\n    let groundDistance = (-params.x - localOrigin.y) / rayDirection.y;\n    let groundHit = localOrigin + rayDirection * groundDistance;\n    let groundRadius = (2.0 / 3.0)\n      * sqrt(params.y * params.y - 2.25 * params.x * params.x);\n    if (groundDistance > 0.0 && length(groundHit.xz) <= groundRadius) {\n      return normalize(groundHit);\n    }\n  }\n\n  var nearDistance = 0.0;\n  for (var i = 0; i < 14; i++) {\n    let middleDistance = (nearDistance + farDistance) * 0.5;\n    let middlePoint = localOrigin + rayDirection * middleDistance;\n    if (groundedSurfaceDistance(middlePoint, params.x, params.y) > 0.0) {\n      farDistance = middleDistance;\n    }\n    else {\n      nearDistance = middleDistance;\n    }\n  }\n  let hit = localOrigin + rayDirection * ((nearDistance + farDistance) * 0.5);\n  return normalize(hit);\n}\n\nfn sampleSceneBackground(ray: Ray) -> vec4f {\n  var bg = vec4f(0.0);\n  if (USE_BACKGROUND_MAP) {\n    let d = groundedBackgroundDirection(ray.o, ray.d);\n    let t = rtUniform.backgroundMapTransform;\n    let backgroundDirection = vec3f(t.x * d.x - t.y * d.z, d.y, t.y * d.x + t.x * d.z);\n    let rotation = rtUniform.backgroundMapRotation;\n    let mapDirection = transpose(mat3x3f(rotation[0].xyz, rotation[1].xyz, rotation[2].xyz)) * backgroundDirection;\n    let backgroundSample = textureLinear(backgroundMap, cartesianToEquirect(mapDirection));\n    bg = vec4f(backgroundSample.rgb * t.z, backgroundSample.a);\n  }\n  else if (USE_BACKGROUND) {\n    bg = rtUniform.backgroundColor;\n  }\n  else if (USE_ENVMAP) {\n    bg = textureLinear(envMap, environmentUv(ray.d));\n  }\n  return bg;\n}\n\n`;\n"]}

package/lib/renderer/wgsl/chunks/causticAdjoint.wgsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\nfn causticAdjoint(view:vec3f,outgoing:vec3f,shading:vec3f,geometric:vec3f)->f32 {\n  let numerator=abs(dot(view,shading)*dot(outgoing,geometric));\n  let denominator=abs(dot(view,geometric)*dot(outgoing,shading));\n  if(denominator==0.0){return 0.0;}\n  return numerator/denominator;\n}\n";
+export default _default;

package/lib/renderer/wgsl/chunks/causticAdjoint.wgsl.js

@@ -0,0 +1,12 @@
+// Veach's adjoint shading-normal ratio. Directions point away from the vertex;
+// view is toward the preceding light vertex, outgoing toward the camera.
+// Reference: Veach 1997, thesis section 5.3 (mathematical formula, no copied code).
+export default /* wgsl */ `
+fn causticAdjoint(view:vec3f,vJ:vec3f,shading:vec3f,geometric:vec3f)->f32 {
+let iF=abs(dot(view,shading)*dot(vJ,geometric));
+let ah=abs(dot(view,geometric)*dot(vJ,shading));
+if(ah==0.0){return 0.0;}
+return iF/ah;
+}
+`;
+//# sourceMappingURL=causticAdjoint.wgsl.js.map

package/lib/renderer/wgsl/chunks/causticAdjoint.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"causticAdjoint.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/causticAdjoint.wgsl.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,yEAAyE;AACzE,oFAAoF;AACpF,eAAe,UAAU,CAAC;;;;;;;CAOzB,CAAC","sourcesContent":["// Veach's adjoint shading-normal ratio. Directions point away from the vertex;\n// view is toward the preceding light vertex, outgoing toward the camera.\n// Reference: Veach 1997, thesis section 5.3 (mathematical formula, no copied code).\nexport default /* wgsl */ `\nfn causticAdjoint(view:vec3f,outgoing:vec3f,shading:vec3f,geometric:vec3f)->f32 {\n  let numerator=abs(dot(view,shading)*dot(outgoing,geometric));\n  let denominator=abs(dot(view,geometric)*dot(outgoing,shading));\n  if(denominator==0.0){return 0.0;}\n  return numerator/denominator;\n}\n`;\n"]}

package/lib/renderer/wgsl/chunks/causticAtomic.wgsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\nfn causticAtomicAdd(index:u32,value:f32) {\n  if(!(value>0.0)||!(value<3.402823e38)){return;}\n  var previous=atomicLoad(&splats[index]);\n  loop {\n    let sum=bitcast<f32>(previous)+value;\n    let replacement=bitcast<u32>(sum);\n    let result=atomicCompareExchangeWeak(&splats[index],previous,replacement);\n    if(result.exchanged){break;}\n    previous=result.old_value;\n  }\n}\n";
+export default _default;

package/lib/renderer/wgsl/chunks/causticAtomic.wgsl.js

@@ -0,0 +1,16 @@
+// Float32 addition implemented with u32 compare/exchange works on baseline
+// WebGPU, without a fixed radiance quantum or the Q16.16 saturation ceiling.
+export default /* wgsl */ `
+fn kM(index:u32,value:f32) {
+if(!(value>0.0)||!(value<3.402823e38)){return;}
+var previous=atomicLoad(&splats[index]);
+loop {
+let sum=bitcast<f32>(previous)+value;
+let vN=bitcast<u32>(sum);
+let result=atomicCompareExchangeWeak(&splats[index],previous,vN);
+if(result.exchanged){break;}
+previous=result.old_value;
+}
+}
+`;
+//# sourceMappingURL=causticAtomic.wgsl.js.map

package/lib/renderer/wgsl/chunks/causticAtomic.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"causticAtomic.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/causticAtomic.wgsl.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,6EAA6E;AAC7E,eAAe,UAAU,CAAC;;;;;;;;;;;;CAYzB,CAAC","sourcesContent":["// Float32 addition implemented with u32 compare/exchange works on baseline\n// WebGPU, without a fixed radiance quantum or the Q16.16 saturation ceiling.\nexport default /* wgsl */ `\nfn causticAtomicAdd(index:u32,value:f32) {\n  if(!(value>0.0)||!(value<3.402823e38)){return;}\n  var previous=atomicLoad(&splats[index]);\n  loop {\n    let sum=bitcast<f32>(previous)+value;\n    let replacement=bitcast<u32>(sum);\n    let result=atomicCompareExchangeWeak(&splats[index],previous,replacement);\n    if(result.exchanged){break;}\n    previous=result.old_value;\n  }\n}\n`;\n"]}

package/lib/renderer/wgsl/chunks/caustics.wgsl.d.ts

@@ -0,0 +1 @@
+export declare function causticPartitionWGSL(mnee: boolean, lightTracing: boolean, photonMapping?: boolean, mneeMaxDepth?: number, hot?: boolean, photonMaxDepth?: number): string;

package/lib/renderer/wgsl/chunks/caustics.wgsl.js

@@ -0,0 +1,62 @@
+// Smooth classification is independent of the sampled lobe. The single-vertex
+// marker records either an eligible delta transmission or a smooth reflection.
+export function causticPartitionWGSL(mnee, lightTracing, photonMapping = false, mneeMaxDepth = 20, hot = false, photonMaxDepth = 20) {
+    return /* wgsl */ `
+fn causticDim(slot:u32)->u32{return 1048576u+samplingBounce*4096u+slot;}
+fn isCausticSpecular(m: OpenPbrResolvedMaterial) -> bool {
+return m.baseWeight * (1.0 - m.baseMetalness) * (1.0 - m.transmissionWeight) <= 1e-6 &&
+m.subsurfaceWeight <= 0.0 && m.fuzzWeight <= 0.0 && m.coatWeight <= 0.0 && m.causticRoughness <= 0.1;
+}
+fn isCausticT(m: OpenPbrResolvedMaterial) -> bool {
+return isCausticSpecular(m) && m.transmissionWeight == 1.0 && m.causticRoughness == 0.0 && !m.thinWalled && !m.causticNormalMapped && m.alpha>=1.0;
+}
+fn isCausticR(m:OpenPbrResolvedMaterial)->bool{
+return isCausticSpecular(m)&&m.causticRoughness==0.0&&!m.causticNormalMapped&&m.alpha>=1.0;
+}
+fn causticHitOwned(path: Path, xd: bool, vl: bool) -> bool {
+let r1 = ${mnee} && xd && path.causticMneeReceiver && path.causticK == 1u && path.causticSingleT;
+let r2 = ${lightTracing} && vl && path.causticK > 0u && path.causticReceiverPrimary;
+let r3=${photonMapping}&&path.causticPhotonReceiver&&path.causticK>0u;
+return path.causticHasReceiver && (r1 || r2 || r3);
+}
+
+var<private> causticHot:array<vec3f,15>;
+fn causticHotRecord(path:Path,emission:vec3f,kind:u32){
+if(!${hot}){return;}
+let value=max(max(path.beta.x*emission.x,path.beta.y*emission.y),path.beta.z*emission.z);
+if(value<=100.0){return;}
+causticHot[9][kind]+=1.0;
+causticHot[0]+=vec3f(1.0,f32(samplingBounce),f32(path.causticK));
+causticHot[1]+=vec3f(select(0.0,1.0,path.causticHasReceiver),select(0.0,1.0,path.causticSingleT),select(0.0,1.0,path.causticReceiverPrimary));
+causticHot[2]+=vec3f(select(0.0,1.0,path.causticMneeReceiver),select(0.0,1.0,path.causticPhotonReceiver),value);
+if(samplingBounce>=3u&&samplingBounce<=8u){causticHot[samplingBounce]+=vec3f(1.0,f32(path.causticK),value);}
+}
+fn causticEstimateRecord(value:vec3f,kind:u32){
+if(!${hot}){return;}
+let peak=max(max(value.x,value.y),value.z);if(peak>100.0){causticHot[10u+kind]+=vec3f(1.0,f32(samplingBounce),peak);}
+}
+fn causticEmitterRecord(si:SurfaceInteraction,path:Path,weight:f32,emission:vec3f){
+if(!${hot}){return;}
+let value=path.beta*weight*emission;if(max(max(value.x,value.y),value.z)<=100.0){return;}
+let material=materialsBuffer[si.materialIndex];
+causticHot[12]+=vec3f(1.0+dot(si.faceNormal,-path.ray.d),select(0.0,1.0,path.fromEye),material.doubleSided);
+causticHot[13]+=vec3f(weight,material.matType,rtUniform.lightWeightTotal);
+causticHot[14]+=vec3f(path.scatteringPdf,dot(material.emission,luminance),max(max(path.beta.x,path.beta.y),path.beta.z));
+}
+fn causticAdvance(path: ptr<function, Path>, m: OpenPbrResolvedMaterial, transmission: bool, surface: bool) {
+if (surface && isCausticSpecular(m)) {
+(*path).causticK++;
+(*path).causticSingleT = (*path).causticK == 1u && ((isCausticT(m) && transmission)||(isCausticR(m)&&!transmission));
+} else {
+(*path).causticK = 0u;
+(*path).causticSingleT = false;
+(*path).causticPhotonReceiver=surface&&samplingBounce<=${photonMaxDepth}u&&m.materialType!=SHADOW_CATCHER;
+(*path).causticHasReceiver = m.materialType != SHADOW_CATCHER;
+(*path).causticMneeReceiver = surface && samplingBounce<=${mneeMaxDepth}u &&
+m.baseWeight*(1.0-m.baseMetalness)*(1.0-m.transmissionWeight)>0.0 && m.subsurfaceWeight==0.0;
+(*path).causticReceiverPrimary = (*path).fromEye && surface;
+}
+}
+`;
+}
+//# sourceMappingURL=caustics.wgsl.js.map

package/lib/renderer/wgsl/chunks/caustics.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"caustics.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/caustics.wgsl.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,+EAA+E;AAC/E,MAAM,UAAU,oBAAoB,CAAC,IAAa,EAAE,YAAqB,EAAC,aAAa,GAAC,KAAK,EAAC,YAAY,GAAC,EAAE,EAAC,GAAG,GAAC,KAAK,EAAC,cAAc,GAAC,EAAE;IACvI,OAAO,UAAU,CAAC;;;;;;;;;;;;;WAaP,IAAI;WACJ,YAAY;SACd,aAAa;;;;;;MAMjB,GAAG;;;;;;;;;;MAUH,GAAG;;;;MAIH,GAAG;;;;;;;;;;;;;;yDAcmD,cAAc;;2DAEZ,YAAY;;;;;CAK1E,CAAC;AACF,CAAC","sourcesContent":["// Smooth classification is independent of the sampled lobe. The single-vertex\n// marker records either an eligible delta transmission or a smooth reflection.\nexport function causticPartitionWGSL(mnee: boolean, lightTracing: boolean,photonMapping=false,mneeMaxDepth=20,hot=false,photonMaxDepth=20) {\n  return /* wgsl */ `\nfn causticDim(slot:u32)->u32{return 1048576u+samplingBounce*4096u+slot;}\nfn isCausticSpecular(m: OpenPbrResolvedMaterial) -> bool {\n  return m.baseWeight * (1.0 - m.baseMetalness) * (1.0 - m.transmissionWeight) <= 1e-6 &&\n    m.subsurfaceWeight <= 0.0 && m.fuzzWeight <= 0.0 && m.coatWeight <= 0.0 && m.causticRoughness <= 0.1;\n}\nfn isCausticT(m: OpenPbrResolvedMaterial) -> bool {\n  return isCausticSpecular(m) && m.transmissionWeight == 1.0 && m.causticRoughness == 0.0 && !m.thinWalled && !m.causticNormalMapped && m.alpha>=1.0;\n}\nfn isCausticR(m:OpenPbrResolvedMaterial)->bool{\n return isCausticSpecular(m)&&m.causticRoughness==0.0&&!m.causticNormalMapped&&m.alpha>=1.0;\n}\nfn causticHitOwned(path: Path, mneeLight: bool, tracingLight: bool) -> bool {\n  let r1 = ${mnee} && mneeLight && path.causticMneeReceiver && path.causticK == 1u && path.causticSingleT;\n  let r2 = ${lightTracing} && tracingLight && path.causticK > 0u && path.causticReceiverPrimary;\n  let r3=${photonMapping}&&path.causticPhotonReceiver&&path.causticK>0u;\n  return path.causticHasReceiver && (r1 || r2 || r3);\n}\n// Private evidence images count only unsuppressed PT contributions above 100 after MIS.\nvar<private> causticHot:array<vec3f,15>;\nfn causticHotRecord(path:Path,emission:vec3f,kind:u32){\n if(!${hot}){return;}\n let value=max(max(path.beta.x*emission.x,path.beta.y*emission.y),path.beta.z*emission.z);\n if(value<=100.0){return;}\n causticHot[9][kind]+=1.0;\n causticHot[0]+=vec3f(1.0,f32(samplingBounce),f32(path.causticK));\n causticHot[1]+=vec3f(select(0.0,1.0,path.causticHasReceiver),select(0.0,1.0,path.causticSingleT),select(0.0,1.0,path.causticReceiverPrimary));\n causticHot[2]+=vec3f(select(0.0,1.0,path.causticMneeReceiver),select(0.0,1.0,path.causticPhotonReceiver),value);\n if(samplingBounce>=3u&&samplingBounce<=8u){causticHot[samplingBounce]+=vec3f(1.0,f32(path.causticK),value);}\n}\nfn causticEstimateRecord(value:vec3f,kind:u32){\n if(!${hot}){return;}\n let peak=max(max(value.x,value.y),value.z);if(peak>100.0){causticHot[10u+kind]+=vec3f(1.0,f32(samplingBounce),peak);}\n}\nfn causticEmitterRecord(si:SurfaceInteraction,path:Path,weight:f32,emission:vec3f){\n if(!${hot}){return;}\n let value=path.beta*weight*emission;if(max(max(value.x,value.y),value.z)<=100.0){return;}\n let material=materialsBuffer[si.materialIndex];\n causticHot[12]+=vec3f(1.0+dot(si.faceNormal,-path.ray.d),select(0.0,1.0,path.fromEye),material.doubleSided);\n causticHot[13]+=vec3f(weight,material.matType,rtUniform.lightWeightTotal);\n causticHot[14]+=vec3f(path.scatteringPdf,dot(material.emission,luminance),max(max(path.beta.x,path.beta.y),path.beta.z));\n}\nfn causticAdvance(path: ptr<function, Path>, m: OpenPbrResolvedMaterial, transmission: bool, surface: bool) {\n  if (surface && isCausticSpecular(m)) {\n    (*path).causticK++;\n    (*path).causticSingleT = (*path).causticK == 1u && ((isCausticT(m) && transmission)||(isCausticR(m)&&!transmission));\n  } else {\n    (*path).causticK = 0u;\n    (*path).causticSingleT = false;\n    (*path).causticPhotonReceiver=surface&&samplingBounce<=${photonMaxDepth}u&&m.materialType!=SHADOW_CATCHER;\n    (*path).causticHasReceiver = m.materialType != SHADOW_CATCHER;\n    (*path).causticMneeReceiver = surface && samplingBounce<=${mneeMaxDepth}u &&\n      m.baseWeight*(1.0-m.baseMetalness)*(1.0-m.transmissionWeight)>0.0 && m.subsurfaceWeight==0.0;\n    (*path).causticReceiverPrimary = (*path).fromEye && surface;\n  }\n}\n`;\n}\n"]}

package/lib/renderer/wgsl/chunks/common.wgsl.js

@@ -11,12 +11,12 @@ const ROUGHNESS_MIN = 0.001;
 
 
 
-fn sR(position: vec3f, geometricNormal: vec3f, direction: vec3f) -> vec3f {
+fn sO(position: vec3f, geometricNormal: vec3f, direction: vec3f) -> vec3f {
 let normal = select(-geometricNormal, geometricNormal, dot(geometricNormal, direction) >= 0.0);
-let rm = vec3i(256.0 * normal);
+let rb = vec3i(256.0 * normal);
 let bits = bitcast<vec3i>(position);
-let xC = bitcast<vec3f>(bits + select(rm, -rm, position < vec3f(0.0)));
-return select(xC, position + normal / 65536.0, abs(position) < vec3f(1.0 / 32.0));
+let ye = bitcast<vec3f>(bits + select(rb, -rb, position < vec3f(0.0)));
+return select(ye, position + normal / 65536.0, abs(position) < vec3f(1.0 / 32.0));
 }
 
 `;

package/lib/renderer/wgsl/chunks/envMap.wgsl.js

@@ -11,40 +11,40 @@ fn textureLinear(tex: texture_2d<f32>, _uv: vec2f) -> vec4f {
 
 let size = vec2f(textureDimensions(tex, 0));
 
-let yq = _uv * size - vec2f(0.5);
-let xI = floor(yq);
-let f = fract(yq);
-let xH = vec2i(xI);
+let uv2f = _uv * size - vec2f(0.5);
+let yj = floor(uv2f);
+let f = fract(uv2f);
+let yi = vec2i(yj);
 let maximum = vec2i(size) - vec2i(1);
 
 
-let s1 = textureLoad(tex, clamp(xH + vec2i(0, 0), vec2i(0), maximum), 0);
-let s2 = textureLoad(tex, clamp(xH + vec2i(1, 0), vec2i(0), maximum), 0);
-let s3 = textureLoad(tex, clamp(xH + vec2i(0, 1), vec2i(0), maximum), 0);
-let s4 = textureLoad(tex, clamp(xH + vec2i(1, 1), vec2i(0), maximum), 0);
+let s1 = textureLoad(tex, clamp(yi + vec2i(0, 0), vec2i(0), maximum), 0);
+let s2 = textureLoad(tex, clamp(yi + vec2i(1, 0), vec2i(0), maximum), 0);
+let s3 = textureLoad(tex, clamp(yi + vec2i(0, 1), vec2i(0), maximum), 0);
+let s4 = textureLoad(tex, clamp(yi + vec2i(1, 1), vec2i(0), maximum), 0);
 
 return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);
 
 }
 
-fn eV(gx: vec3f) -> vec2f {
-var phi = atan2(-gx.z, -gx.x);
+fn eF(gh: vec3f) -> vec2f {
+var phi = atan2(-gh.z, -gh.x);
 if (phi < 0.0) {
 phi += TWOPI;
 }
-let theta = acos(clamp(gx.y, -1.0, 1.0));
+let theta = acos(clamp(gh.y, -1.0, 1.0));
 return vec2f(phi * 0.5 * INVPI, theta * INVPI);
 }
 
-fn ko() -> mat3x3f {
+fn jS() -> mat3x3f {
 return mat3x3f(rtUniform.environmentRotation[0].xyz, rtUniform.environmentRotation[1].xyz, rtUniform.environmentRotation[2].xyz);
 }
 
-fn dm(nO: vec3f) -> vec2f {
-return eV(transpose(ko()) * nO);
+fn cT(nD: vec3f) -> vec2f {
+return eF(transpose(jS()) * nD);
 }
 
-fn rE(u: f32, vOffset: ptr<function, i32>, pdf: ptr<function, vec2f>) -> f32 {
+fn rv(u: f32, vOffset: ptr<function, i32>, pdf: ptr<function, vec2f>) -> f32 {
 let size = vec2i(textureDimensions(envMap, 0));
 
 var left = 0;
@@ -70,7 +70,7 @@ let s1 = textureLoad(envMapDistribution, vec2i(0, *vOffset + 1), 0).xy;
 return (f32(*vOffset) +  (u - s0.x) / (s1.x - s0.x)) / f32(size.y);
 }
 
-fn rD(u: f32, vOffset: i32, pdf: ptr<function, vec2f>) -> f32 {
+fn ru(u: f32, vOffset: i32, pdf: ptr<function, vec2f>) -> f32 {
 let size = vec2i(textureDimensions(envMap, 0));
 
 var left = 0;
@@ -84,57 +84,57 @@ left = mid + 1;
 right = mid;
 }
 }
-let pO = left - 1;
+let pw = left - 1;
 
 
 
-let s0 = textureLoad(envMapDistribution, vec2i(1 + pO, vOffset), 0).xy;
-let s1 = textureLoad(envMapDistribution, vec2i(1 + pO + 1, vOffset), 0).xy;
+let s0 = textureLoad(envMapDistribution, vec2i(1 + pw, vOffset), 0).xy;
+let s1 = textureLoad(envMapDistribution, vec2i(1 + pw + 1, vOffset), 0).xy;
 
 (*pdf).x = s0.y;
 
-return (f32(pO) + (u - s0.x) / (s1.x - s0.x)) / f32(size.x);
+return (f32(pw) + (u - s0.x) / (s1.x - s0.x)) / f32(size.x);
 }
 
 
 
-fn eW(ew: vec2f, v: f32) -> f32 {
+fn envMapSolidAnglePdf(partialPdf: vec2f, v: f32) -> f32 {
 if (!(v > 0.0 && v < 1.0)) { return 0.0; }
 let sinTheta = sin(min(v, 1.0 - v) * PI);
-return ew.x * ew.y * INVPI2 / (2.0 * sinTheta);
+return partialPdf.x * partialPdf.y * INVPI2 / (2.0 * sinTheta);
 }
 
 
-fn pI(random: vec2f, uv: ptr<function, vec2f>, pdf: ptr<function, f32>) -> vec3f {
-var ew: vec2f;
+fn pn(random: vec2f, uv: ptr<function, vec2f>, pdf: ptr<function, f32>) -> vec3f {
+var partialPdf: vec2f;
 var vOffset: i32;
 
-(*uv).y = rE(random.x, &vOffset, &ew);
-(*uv).x = rD(random.y, vOffset, &ew);
+(*uv).y = rv(random.x, &vOffset, &partialPdf);
+(*uv).x = ru(random.y, vOffset, &partialPdf);
 
 let phi = (*uv).x * TWOPI;
 let theta = (*uv).y * PI;
-let ci = cos(theta);
+let ct = cos(theta);
 let sinTheta = sin(theta);
-let vM = cos(phi);
-let vX = sin(phi);
+let vZ = cos(phi);
+let wr = sin(phi);
 
-let dir = vec3f(-sinTheta * vM, ci, -sinTheta * vX);
+let dir = vec3f(-sinTheta * vZ, ct, -sinTheta * wr);
 
-*pdf = eW(ew, (*uv).y);
+*pdf = envMapSolidAnglePdf(partialPdf, (*uv).y);
 
-return ko() * dir;
+return jS() * dir;
 }
 
-fn iT(_uv: vec2f) -> f32 {
+fn envMapPdf(_uv: vec2f) -> f32 {
 let size = vec2f(textureDimensions(envMap, 0));
 
-let xO = clamp(vec2i(_uv * size), vec2i(0), vec2i(size) - vec2i(1));
+let yn = clamp(vec2i(_uv * size), vec2i(0), vec2i(size) - vec2i(1));
 
-let ub = textureLoad(envMapDistribution, vec2i(1 + xO.x, xO.y), 0).y;
-let uc = textureLoad(envMapDistribution, vec2i(0, xO.y), 0).y;
+let ue = textureLoad(envMapDistribution, vec2i(1 + yn.x, yn.y), 0).y;
+let uf = textureLoad(envMapDistribution, vec2i(0, yn.y), 0).y;
 
-return eW(vec2f(ub, uc), _uv.y);
+return envMapSolidAnglePdf(vec2f(ue, uf), _uv.y);
 }