@meimu/mutracer 0.1.5 → 0.2.0

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

@@ -0,0 +1,121 @@
+import bsdf from './chunks/openPbrBsdf.glsl.js';
+import sampling from './chunks/sampling.glsl.js';
+import reflectance from './aovReflectance.glsl.js';
+import { FragmentShader, Shader } from '../shader.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 cameraRay from './chunks/cameraRay.glsl.js';
+import rand from './chunks/rand.glsl.js';
+const surface = /* glsl */ `
+uint ke(int index) { ivec2 size = textureSize(aovScene,0); uvec4 v = texelFetch(aovScene, ivec2((index/4)%size.x, (index/4)/size.x),0); return v[index%4]; }
+vec3 iN(int offset){return vec3(uintBitsToFloat(ke(offset)),uintBitsToFloat(ke(offset+1)),uintBitsToFloat(ke(offset+2)));}
+mat4 ow(int offset) { mat4 m; for (int i=0;i<4;i++) for(int j=0;j<4;j++) m[i][j]=uintBitsToFloat(ke(offset+i*4+j)); return m; }
+Ray wJ(vec2 uv) {
+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)); return ray;
+}
+bool mQ(Ray wX, out SurfaceInteraction si, out OpenPbrResolvedMaterial material) {
+Ray ray=wX; si.triangleIndex=-1;
+for(int layer=0;layer<32;layer++) {
+intersectScene(ray,si,false); if(!si.hit) return false;
+dg(material,si.materialIndex,si.uv,si.uv1,si.instanceIndex,si.vertexColor);
+if(material.materialType!=SHADOW_CATCHER && material.alpha>=0.5) return true;
+ray.o=si.position+ray.d*(EPS*0.02);
+}
+return false;
+}
+`;
+export function aovTraceFragment(center) {
+    const shader = new FragmentShader({ name: center ? 'AOV center' : 'AOV accumulation',
+        outputs: center ? ['id', 'motion'] : ['geometry', 'position', 'diffuse', 'specular'],
+        outputTypes: center ? { id: 'uvec4' } : {}, defines: { DEPTH_QUERY_MODE: true },
+        includes: [core, materials, intersect, random],
+        uniforms: { viewProjectionInv: Shader.uniform('mat4'), viewInv: Shader.uniform('mat4'),
+            cameraApertureRadius: Shader.uniform('float', 0), cameraFocusDistance: Shader.uniform('float', 10),
+            viewportSize: Shader.uniform('vec2'), aovScene: Shader.uniform('usampler2D'),
+            previousId: Shader.uniform('usampler2D'), previousMotion: Shader.uniform('sampler2D'),
+            previousGeometry: Shader.uniform('sampler2D'), previousPosition: Shader.uniform('sampler2D'),
+            previousDiffuse: Shader.uniform('sampler2D'), previousSpecular: Shader.uniform('sampler2D'),
+            openPbrEnergyLut: Shader.uniform('sampler2D'), aovMask: Shader.uniform('int', 0),
+            aovSample: Shader.uniform('int', 0) },
+        main: /* glsl */ `
+${common}
+${rand}
+${random.main}
+${core.main}
+${uvProjection}
+${materials.main}
+${intersect.main}
+${cameraRay}
+${center ? '' : sampling + bsdf + reflectance}
+${surface}
+void main() {
+${center ? /* glsl */ `
+out_id=uvec4(0xffffffffu); out_motion=vec4(0.0);
+Ray ray=wJ((floor(gl_FragCoord.xy)+0.5)/viewportSize);
+SurfaceInteraction si; OpenPbrResolvedMaterial material;
+if(!mQ(ray,si,material)) return;
+int offset=52+si.instanceIndex*24;
+out_id=uvec4(ke(offset),ke(offset+1),ke(int(ke(16))+si.materialIndex),ke(int(ke(17))+si.triangleIndex));
+out_motion.z=dot(si.position-iN(36),iN(40));
+if(ke(offset+2)==0u)return;
+vec4 qA=ow(offset+4)*vec4(si.position,1.0);
+vec4 ps=ow(0)*qA;
+if(ps.w<=0.0)return;
+vec3 tX=ps.xyz/ps.w;vec2 iz=(tX.xy*0.5+0.5)*viewportSize;
+if(any(lessThan(iz,vec2(0.0)))||any(greaterThanEqual(iz,viewportSize))||abs(tX.z)>1.0)return;
+uvec4 identity=texelFetch(previousId,ivec2(iz),0);float qz=texelFetch(previousMotion,ivec2(iz),0).z;
+if(any(notEqual(identity.xy,out_id.xy))||abs(qz-dot(qA.xyz-iN(44),iN(48)))>max(1e-4,abs(qz)*1e-3))return;
+out_motion=vec4((iz-gl_FragCoord.xy)*vec2(1.0,-1.0),out_motion.z,3.0);
+` : /* glsl */ `
+ivec2 coord=ivec2(gl_FragCoord.xy);
+out_geometry=aovSample==0 ? vec4(0.0) : texelFetch(previousGeometry,coord,0);
+out_position=aovSample==0 ? vec4(0.0) : texelFetch(previousPosition,coord,0);
+out_diffuse=aovSample==0 ? vec4(0.0) : texelFetch(previousDiffuse,coord,0);
+out_specular=aovSample==0 ? vec4(0.0) : texelFetch(previousSpecular,coord,0);
+rG(); aZ=uvec2(floor(gl_FragCoord.xy));
+gW(floor(gl_FragCoord.xy),int(aQ ^ dG(uint(sequenceSeed))));
+Ray ray=wJ((floor(gl_FragCoord.xy)+dZ(CAMERA_PIXEL))/viewportSize);
+if(cameraApertureRadius>0.0) {
+vec3 eye=viewInv[3].xyz, forward=-normalize(viewInv[2].xyz);
+vec3 jN=eye+ray.d*(cameraFocusDistance/dot(ray.d,forward));
+vec2 xU=cameraApertureRadius*kN(dZ(CAMERA_LENS));
+vec3 origin=(viewInv*vec4(xU,0.0,1.0)).xyz;
+gC(ray,origin,normalize(jN-origin));
+}
+SurfaceInteraction si; OpenPbrResolvedMaterial material;
+if(!mQ(ray,si,material)) return;
+float depth=max(dot(si.position-viewInv[3].xyz,-normalize(viewInv[2].xyz)),0.0);
+bool unsupported=material.materialType!=STANDARD || material.alpha<1.0 || material.coatWeight>0.0 || material.fuzzWeight>0.0 || material.specularAnisotropy>0.0 || material.subsurfaceWeight>0.0 || dot(material.mediumScattering,material.mediumScattering)>0.0 || material.bevel>0.0 || material.thinFilmWeight>0.0 || material.transmissionDispersionScale>0.0;
+out_geometry+=vec4(depth,material.specularRoughness,material.baseMetalness,unsupported?1.0:0.0);
+#ifdef AOV_REFLECTANCE
+if((aovMask&24)!=0 && !unsupported){
+vec3 normal=si.normal,face=si.faceNormal;float cosine=-dot(normal,ray.d),fu=-dot(face,ray.d);
+if(material.thinWalled&&(material.transmissionWeight>0.0||material.subsurfaceWeight>0.0)){
+if(cosine<0.0){normal=-normal;cosine=-cosine;}if(fu<0.0){face=-face;fu=-fu;}
+}
+if(fu>=0.0&&cosine<0.0){normal=face;cosine=fu;}
+if(cosine<0.0)normal=-normal;
+material.inside=cosine<=0.0&&!material.thinWalled;material.relativeIor=cosine>0.0?1.0/material.specularIor:material.specularIor;
+vec3 tangent=vec3(0.0);
+#ifdef USE_TANGENT
+tangent=si.tangent;
+#endif
+ag prepared=ds(tangent,material,-ray.d,normal);
+vec3 diffuse,specular;aovReflectance(prepared,(aovMask&8)!=0,(aovMask&16)!=0,diffuse,specular);
+out_diffuse+=vec4(diffuse,1.0);out_specular+=vec4(specular,1.0);
+}
+#endif
+out_position+=vec4(si.position,1.0);
+`}
+}
+` });
+    shader.parallelCompile = true;
+    return shader;
+}
+//# sourceMappingURL=aovTrace.frag.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aovTrace.frag.js","sourceRoot":"","sources":["../../../src/renderer/glsl/aovTrace.frag.ts"],"names":[],"mappings":"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","sourcesContent":["import bsdf from './chunks/openPbrBsdf.glsl.js';\nimport sampling from './chunks/sampling.glsl.js';\nimport reflectance from './aovReflectance.glsl.js';\nimport {FragmentShader, Shader} from '../shader.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 cameraRay from './chunks/cameraRay.glsl.js';\nimport rand from './chunks/rand.glsl.js';\nconst surface = /* glsl */ `\nuint aovWord(int index) { ivec2 size = textureSize(aovScene,0); uvec4 v = texelFetch(aovScene, ivec2((index/4)%size.x, (index/4)/size.x),0); return v[index%4]; }\nvec3 aovVector(int offset){return vec3(uintBitsToFloat(aovWord(offset)),uintBitsToFloat(aovWord(offset+1)),uintBitsToFloat(aovWord(offset+2)));}\nmat4 aovMatrix(int offset) { mat4 m; for (int i=0;i<4;i++) for(int j=0;j<4;j++) m[i][j]=uintBitsToFloat(aovWord(offset+i*4+j)); return m; }\nRay aovRay(vec2 uv) {\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; initRay(ray, origin.xyz/origin.w, normalize(target.xyz*origin.w-origin.xyz*target.w)); return ray;\n}\nbool aovSurface(Ray inputRay, out SurfaceInteraction si, out OpenPbrResolvedMaterial material) {\n  Ray ray=inputRay; si.triangleIndex=-1;\n  for(int layer=0;layer<32;layer++) {\n    intersectScene(ray,si,false); if(!si.hit) return false;\n    getMaterial(material,si.materialIndex,si.uv,si.uv1,si.instanceIndex,si.vertexColor);\n    if(material.materialType!=SHADOW_CATCHER && material.alpha>=0.5) return true;\n    ray.o=si.position+ray.d*(EPS*0.02);\n  }\n  return false;\n}\n`;\nexport function aovTraceFragment(center: boolean) {\n  const shader = new FragmentShader({name: center ? 'AOV center' : 'AOV accumulation',\n    outputs: center ? ['id','motion'] : ['geometry','position','diffuse','specular'],\n    outputTypes: center ? {id: 'uvec4'} : {}, defines: {DEPTH_QUERY_MODE: true},\n    includes: [core,materials,intersect,random],\n    uniforms: {viewProjectionInv: Shader.uniform('mat4'), viewInv: Shader.uniform('mat4'),\n      cameraApertureRadius: Shader.uniform('float',0), cameraFocusDistance: Shader.uniform('float',10),\n      viewportSize: Shader.uniform('vec2'), aovScene: Shader.uniform('usampler2D'),\n      previousId: Shader.uniform('usampler2D'), previousMotion: Shader.uniform('sampler2D'),\n      previousGeometry: Shader.uniform('sampler2D'), previousPosition: Shader.uniform('sampler2D'),\n      previousDiffuse: Shader.uniform('sampler2D'), previousSpecular: Shader.uniform('sampler2D'),\n      openPbrEnergyLut: Shader.uniform('sampler2D'), aovMask: Shader.uniform('int',0),\n      aovSample: Shader.uniform('int',0)},\n    main: /* glsl */ `\n${common}\n${rand}\n${random.main}\n${core.main}\n${uvProjection}\n${materials.main}\n${intersect.main}\n${cameraRay}\n${center ? '' : sampling+bsdf+reflectance}\n${surface}\nvoid main() {\n  ${center ? /* glsl */ `\n  out_id=uvec4(0xffffffffu); out_motion=vec4(0.0);\n  Ray ray=aovRay((floor(gl_FragCoord.xy)+0.5)/viewportSize);\n  SurfaceInteraction si; OpenPbrResolvedMaterial material;\n  if(!aovSurface(ray,si,material)) return;\n  int offset=52+si.instanceIndex*24;\n  out_id=uvec4(aovWord(offset),aovWord(offset+1),aovWord(int(aovWord(16))+si.materialIndex),aovWord(int(aovWord(17))+si.triangleIndex));\n  out_motion.z=dot(si.position-aovVector(36),aovVector(40));\n  if(aovWord(offset+2)==0u)return;\n  vec4 oldWorld=aovMatrix(offset+4)*vec4(si.position,1.0);\n  vec4 oldClip=aovMatrix(0)*oldWorld;\n  if(oldClip.w<=0.0)return;\n  vec3 oldNdc=oldClip.xyz/oldClip.w;vec2 oldPixel=(oldNdc.xy*0.5+0.5)*viewportSize;\n  if(any(lessThan(oldPixel,vec2(0.0)))||any(greaterThanEqual(oldPixel,viewportSize))||abs(oldNdc.z)>1.0)return;\n  uvec4 identity=texelFetch(previousId,ivec2(oldPixel),0);float oldDepth=texelFetch(previousMotion,ivec2(oldPixel),0).z;\n  if(any(notEqual(identity.xy,out_id.xy))||abs(oldDepth-dot(oldWorld.xyz-aovVector(44),aovVector(48)))>max(1e-4,abs(oldDepth)*1e-3))return;\n  out_motion=vec4((oldPixel-gl_FragCoord.xy)*vec2(1.0,-1.0),out_motion.z,3.0);\n  ` : /* glsl */ `\n  ivec2 coord=ivec2(gl_FragCoord.xy);\n  out_geometry=aovSample==0 ? vec4(0.0) : texelFetch(previousGeometry,coord,0);\n  out_position=aovSample==0 ? vec4(0.0) : texelFetch(previousPosition,coord,0);\n  out_diffuse=aovSample==0 ? vec4(0.0) : texelFetch(previousDiffuse,coord,0);\n  out_specular=aovSample==0 ? vec4(0.0) : texelFetch(previousSpecular,coord,0);\n  initRandom(); samplingPixel=uvec2(floor(gl_FragCoord.xy));\n  rng_initialize(floor(gl_FragCoord.xy),int(pixelSampleIndex ^ sampleHash(uint(sequenceSeed))));\n  Ray ray=aovRay((floor(gl_FragCoord.xy)+sample2D(CAMERA_PIXEL))/viewportSize);\n  if(cameraApertureRadius>0.0) {\n    vec3 eye=viewInv[3].xyz, forward=-normalize(viewInv[2].xyz);\n    vec3 focusPoint=eye+ray.d*(cameraFocusDistance/dot(ray.d,forward));\n    vec2 lens=cameraApertureRadius*sampleCircle(sample2D(CAMERA_LENS));\n    vec3 origin=(viewInv*vec4(lens,0.0,1.0)).xyz;\n    initRay(ray,origin,normalize(focusPoint-origin));\n  }\n  SurfaceInteraction si; OpenPbrResolvedMaterial material;\n  if(!aovSurface(ray,si,material)) return;\n  float depth=max(dot(si.position-viewInv[3].xyz,-normalize(viewInv[2].xyz)),0.0);\n  bool unsupported=material.materialType!=STANDARD || material.alpha<1.0 || material.coatWeight>0.0 || material.fuzzWeight>0.0 || material.specularAnisotropy>0.0 || material.subsurfaceWeight>0.0 || dot(material.mediumScattering,material.mediumScattering)>0.0 || material.bevel>0.0 || material.thinFilmWeight>0.0 || material.transmissionDispersionScale>0.0;\n  out_geometry+=vec4(depth,material.specularRoughness,material.baseMetalness,unsupported?1.0:0.0);\n  #ifdef AOV_REFLECTANCE\n  if((aovMask&24)!=0 && !unsupported){\n    vec3 normal=si.normal,face=si.faceNormal;float cosine=-dot(normal,ray.d),faceCosine=-dot(face,ray.d);\n    if(material.thinWalled&&(material.transmissionWeight>0.0||material.subsurfaceWeight>0.0)){\n      if(cosine<0.0){normal=-normal;cosine=-cosine;}if(faceCosine<0.0){face=-face;faceCosine=-faceCosine;}\n    }\n    if(faceCosine>=0.0&&cosine<0.0){normal=face;cosine=faceCosine;}\n    if(cosine<0.0)normal=-normal;\n    material.inside=cosine<=0.0&&!material.thinWalled;material.relativeIor=cosine>0.0?1.0/material.specularIor:material.specularIor;\n    vec3 tangent=vec3(0.0);\n#ifdef USE_TANGENT\n    tangent=si.tangent;\n#endif\n    OpenPbrPreparedBsdf prepared=openpbr_prepare(tangent,material,-ray.d,normal);\n    vec3 diffuse,specular;aovReflectance(prepared,(aovMask&8)!=0,(aovMask&16)!=0,diffuse,specular);\n    out_diffuse+=vec4(diffuse,1.0);out_specular+=vec4(specular,1.0);\n  }\n  #endif\n  out_position+=vec4(si.position,1.0);\n  `}\n}\n`});\n  shader.parallelCompile = true;\n  return shader;\n}\n"]}

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

@@ -3,16 +3,16 @@
 // Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.
 // Shared primary-ray construction keeps beauty and catcher coverage aligned.
 export default /* glsl */ `
-Ray hC(vec2 fH) {
-vec4 origin = viewProjectionInv * vec4(fH * 2.0 - 1.0, -1.0, 1.0);
-vec4 target = viewProjectionInv * vec4(fH * 2.0 - 1.0, 1.0, 1.0);
+Ray fj(vec2 coord) {
+vec4 origin = viewProjectionInv * vec4(coord * 2.0 - 1.0, -1.0, 1.0);
+vec4 target = viewProjectionInv * vec4(coord * 2.0 - 1.0, 1.0, 1.0);
 Ray cam;
-iC(cam, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * target.w));
+gC(cam, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * target.w));
 
 return cam;
 }
 
-vec2 oK(vec2 p) {
+vec2 kN(vec2 p) {
 p = 2.0 * p - 1.0;
 bool greater = abs(p.x) > abs(p.y);
 float r = greater ? p.x : p.y;
@@ -20,16 +20,16 @@ float theta = greater ? 0.25 * PI * p.y / p.x : PI * (0.5 - 0.25 * p.x / p.y);
 return r * vec2(cos(theta), sin(theta));
 }
 
-Ray nM() {
-Ray cam = hC(v_Texcoord + sa());
+Ray oG() {
+Ray cam = fj(v_Texcoord + tg());
 if (cameraApertureRadius > 0.0) {
 
 vec3 eye = viewInv[3].xyz;
-vec3 oj = -normalize(viewInv[2].xyz);
-vec3 qy = eye + cam.d * (cameraFocusDistance / dot(cam.d, oj));
-vec2 rK = cameraApertureRadius * oK(fp(CAMERA_LENS));
-vec3 origin = vec3(viewInv * vec4(rK, 0.0, 1.0));
-iC(cam, origin, normalize(qy - origin));
+vec3 forward = -normalize(viewInv[2].xyz);
+vec3 jN = eye + cam.d * (cameraFocusDistance / dot(cam.d, forward));
+vec2 sK = cameraApertureRadius * kN(dZ(CAMERA_LENS));
+vec3 origin = vec3(viewInv * vec4(sK, 0.0, 1.0));
+gC(cam, origin, normalize(jN - origin));
 }
 return cam;
 }

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

@@ -11,21 +11,22 @@ export default createShaderMixin({
         envMapDistribution: Shader.uniform('sampler2D'),
         backgroundMap: Shader.uniform('sampler2D'),
         backgroundMapTransform: Shader.uniform('vec4', [1, 0, 1, 0]),
+        backgroundMapRotation: Shader.uniform('mat3', [1, 0, 0, 0, 1, 0, 0, 0, 1]),
         groundedBackgroundParams: Shader.uniform('vec4'),
         groundedBackgroundCenter: Shader.uniform('vec2')
     },
     main: glsl `
-vec2 eL(vec3 gh) {
-float phi = mod(atan(-gh.z, -gh.x), TWOPI);
-float theta = acos(clamp(gh.y, -1.0, 1.0));
+vec2 eV(vec3 gx) {
+float phi = mod(atan(-gx.z, -gx.x), TWOPI);
+float theta = acos(clamp(gx.y, -1.0, 1.0));
 return vec2(phi * 0.5 * INVPI, theta * INVPI);
 }
 
-vec2 cY(vec3 mP) {
-return eL(transpose(environmentRotation) * mP);
+vec2 dm(vec3 nO) {
+return eV(transpose(environmentRotation) * nO);
 }
 
-float qB(float u, out int vOffset, out float pdf) {
+float rE(float u, out int vOffset, out float pdf) {
 ivec2 size = textureSize(envMap, 0);
 
 int left = 0;
@@ -51,7 +52,7 @@ pdf = s0.y;
 return (float(vOffset) +  (u - s0.x) / (s1.x - s0.x)) / float(size.y);
 }
 
-float qA(float u, int vOffset, out float pdf) {
+float rD(float u, int vOffset, out float pdf) {
 ivec2 size = textureSize(envMap, 0);
 
 int left = 0;
@@ -65,123 +66,128 @@ left = mid + 1;
 right = mid;
 }
 }
-int oR = left - 1;
+int pO = left - 1;
 
 
 
-vec2 s0 = texelFetch(envMapDistribution, ivec2(1 + oR, vOffset), 0).xy;
-vec2 s1 = texelFetch(envMapDistribution, ivec2(1 + oR + 1, vOffset), 0).xy;
+vec2 s0 = texelFetch(envMapDistribution, ivec2(1 + pO, vOffset), 0).xy;
+vec2 s1 = texelFetch(envMapDistribution, ivec2(1 + pO + 1, vOffset), 0).xy;
 
 pdf = s0.y;
 
-return (float(oR) + (u - s0.x) / (s1.x - s0.x)) / float(size.x);
+return (float(pO) + (u - s0.x) / (s1.x - s0.x)) / float(size.x);
 }
 
 
-vec3 oL(vec2 random, out vec2 uv, out float pdf) {
-vec2 he;
+float eW(vec2 ew, float v) {
+if (!(v > 0.0 && v < 1.0)) { return 0.0; }
+float sinTheta = sin(min(v, 1.0 - v) * PI);
+return ew.x * ew.y * INVPI2 / (2.0 * sinTheta);
+}
+
+
+vec3 pI(vec2 random, out vec2 uv, out float pdf) {
+vec2 ew;
 int vOffset;
 
-uv.y = qB(random.x, vOffset, he.y);
-uv.x = qA(random.y, vOffset, he.x);
+uv.y = rE(random.x, vOffset, ew.y);
+uv.x = rD(random.y, vOffset, ew.x);
 
 float phi = uv.x * TWOPI;
 float theta = uv.y * PI;
-float cc = cos(theta);
+float ci = cos(theta);
 float sinTheta = sin(theta);
-float ul = cos(phi);
-float uw = sin(phi);
+float vM = cos(phi);
+float vX = sin(phi);
 
-vec3 dir = vec3(-sinTheta * ul, cc, -sinTheta * uw);
+vec3 dir = vec3(-sinTheta * vM, ci, -sinTheta * vX);
 
-pdf = he.x * he.y * INVPI2 / (2.0 * sinTheta);
+pdf = eW(ew, uv.y);
 
 return environmentRotation * dir;
 }
 
-float iB(vec2 uv) {
+float iT(vec2 uv) {
 vec2 size = vec2(textureSize(envMap, 0));
 
-float sinTheta = sin(uv.y * PI);
-
-uv *= size;
+ivec2 pixel = clamp(ivec2(uv * size), ivec2(0), ivec2(size) - ivec2(1));
 
-float sL = texelFetch(envMapDistribution, ivec2(1.0 + uv.x, uv.y), 0).y;
-float sM = texelFetch(envMapDistribution, ivec2(0, uv.y), 0).y;
+float ub = texelFetch(envMapDistribution, ivec2(1 + pixel.x, pixel.y), 0).y;
+float uc = texelFetch(envMapDistribution, ivec2(0, pixel.y), 0).y;
 
-return sL * sM * INVPI2 / (2.0 * sinTheta);
+return eW(vec2(ub, uc), uv.y);
 }
 
-float dq(vec3 sN, float height, float radius) {
-float fR = length(sN);
-if (fR < 0.00001) {
+float dK(vec3 point, float height, float radius) {
+float ge = length(point);
+if (ge < 0.00001) {
 return -radius;
 }
 
-float iG = radius * sN.y / fR;
-float iq = -1.5 * height;
-float ev;
-if (iG >= 0.0) {
-ev = radius;
-} else if (iG < iq) {
-ev = -height * fR / sN.y;
+float iX = radius * point.y / ge;
+float iL = -1.5 * height;
+float eH;
+if (iX >= 0.0) {
+eH = radius;
+} else if (iX < iL) {
+eH = -height * ge / point.y;
 } else {
-float dW = 1.0
-- iG * iG / (3.0 * iq * iq);
-ev = radius * dW;
+float cL = 1.0
+- iX * iX / (3.0 * iL * iL);
+eH = radius * cL;
 }
-return fR - ev;
+return ge - eH;
 }
 
-vec3 eT(vec3 origin, vec3 d) {
+vec3 fd(vec3 origin, vec3 d) {
 #ifdef USE_GROUNDED_BACKGROUND
 float height = groundedBackgroundParams.x;
 float radius = groundedBackgroundParams.y;
-float vN = groundedBackgroundParams.z;
-vec3 bY = normalize(d);
-vec3 bB = origin - vec3(
+float xB = groundedBackgroundParams.z;
+vec3 cf = normalize(d);
+vec3 bI = origin - vec3(
 groundedBackgroundCenter.x,
-vN + height,
+xB + height,
 groundedBackgroundCenter.y
 );
 
 
 
-float eJ = dot(bB, bY);
-float ej = eJ * eJ
-- dot(bB, bB) + radius * radius;
-if (ej > 0.0) {
-float cC = -eJ + sqrt(ej);
+float eT = dot(bI, cf);
+float br = eT * eT
+- dot(bI, bI) + radius * radius;
+if (br > 0.0) {
+float cM = -eT + sqrt(br);
 if (
-cC > 0.0
-&& dq(bB, height, radius) <= 0.0
+cM > 0.0
+&& dK(bI, height, radius) <= 0.0
 ) {
-vec3 nO = bB + bY * cC;
-if (nO.y >= 0.0) {
-return normalize(nO);
+vec3 oK = bI + cf * cM;
+if (oK.y >= 0.0) {
+return normalize(oK);
 }
 
-if (bY.y < -0.00001 && radius > 1.5 * height) {
-float hT = (-height - bB.y) / bY.y;
-vec3 nE = bB + bY * hT;
-float om = (2.0 / 3.0)
+if (cf.y < -0.00001 && radius > 1.5 * height) {
+float ir = (-height - bI.y) / cf.y;
+vec3 oB = bI + cf * ir;
+float pe = (2.0 / 3.0)
 * sqrt(radius * radius - 2.25 * height * height);
-if (hT > 0.0 && length(nE.xz) <= om) {
-return normalize(nE);
+if (ir > 0.0 && length(oB.xz) <= pe) {
+return normalize(oB);
 }
 }
 
-float cN = 0.0;
+float cV = 0.0;
 for (int i = 0; i < 14; i++) {
-float fh = (cN + cC) * 0.5;
-vec3 pL = bB + bY * fh;
-if (dq(pL, height, radius) > 0.0) {
-cC = fh;
+float fB = (cV + cM) * 0.5;
+vec3 qy = bI + cf * fB;
+if (dK(qy, height, radius) > 0.0) {
+cM = fB;
 } else {
-cN = fh;
+cV = fB;
 }
 }
-vec3 hit = bB + bY * ((cN + cC) * 0.5);
+vec3 hit = bI + cf * ((cV + cM) * 0.5);
 return normalize(hit);
 }
 }
@@ -189,15 +195,15 @@ return normalize(hit);
 return d;
 }
 
-vec4 cx(vec3 origin, vec3 d) {
-d = eT(origin, d);
+vec4 cG(vec3 origin, vec3 d) {
+d = fd(origin, d);
 #ifdef USE_BACKGROUND
 vec4 t = backgroundMapTransform;
 d = vec3(t.x * d.x - t.y * d.z, d.y, t.y * d.x + t.x * d.z);
-vec4 aW = textureLinear(backgroundMap, eL(d));
-return vec4(aW.rgb * t.z, aW.a);
+vec4 bc = textureLinear(backgroundMap, eV(transpose(backgroundMapRotation) * d));
+return vec4(bc.rgb * t.z, bc.a);
 #else
-return textureLinear(backgroundMap, cY(d));
+return textureLinear(backgroundMap, dm(d));
 #endif
 }`
 });

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

@@ -1 +1 @@
-{"version":3,"file":"envMap.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/envMap.glsl.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,sFAAsF;AACtF,uHAAuH;AAEvH,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAElE,eAAe,iBAAiB,CAAC;IAC/B,QAAQ,EAAE;QACR,mBAAmB,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAE,CAAC,EAAC,CAAC,EAAC,CAAC,EAAE,CAAC,EAAC,CAAC,EAAC,CAAC,CAAC,CAAC;QAClE,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QACnC,kBAAkB,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QAC/C,aAAa,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QAC1C,sBAAsB,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,CAAC,CAAC;QACzD,wBAAwB,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;QAChD,wBAAwB,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;KACjD;IACD,IAAI,EAAE,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyLV;CACD,CAAC,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// Sample the environment map using a cumulative distribution function as described in\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Sampling_Light_Sources.html#InfiniteAreaLights\n\nimport { createShaderMixin, glsl, Shader } from '../../shader.js';\n\nexport default createShaderMixin({\n  uniforms: {\n    environmentRotation: Shader.uniform('mat3', [1,0,0, 0,1,0, 0,0,1]),\n    envMap: Shader.uniform('sampler2D'),\n    envMapDistribution: Shader.uniform('sampler2D'),\n    backgroundMap: Shader.uniform('sampler2D'),\n    backgroundMapTransform: Shader.uniform('vec4', [1,0,1,0]),\n    groundedBackgroundParams: Shader.uniform('vec4'),\n    groundedBackgroundCenter: Shader.uniform('vec2')\n  },\n  main: glsl`\nvec2 cartesianToEquirect(vec3 pointOnSphere) {\n  float phi = mod(atan(-pointOnSphere.z, -pointOnSphere.x), TWOPI);\n  float theta = acos(clamp(pointOnSphere.y, -1.0, 1.0));\n  return vec2(phi * 0.5 * INVPI, theta * INVPI);\n}\n\nvec2 environmentUv(vec3 worldDirection) {\n  return cartesianToEquirect(transpose(environmentRotation) * worldDirection);\n}\n\nfloat getEnvmapV(float u, out int vOffset, out float pdf) {\n  ivec2 size = textureSize(envMap, 0);\n\n  int left = 0;\n  int right = size.y + 1; // cdf length is the length of the env map + 1\n  while (left < right) {\n    int mid = (left + right) >> 1;\n    float s = texelFetch(envMapDistribution, ivec2(0, mid), 0).x;\n    if (s <= u) {\n      left = mid + 1;\n    } else {\n      right = mid;\n    }\n  }\n  vOffset = left - 1;\n\n  // x channel is cumulative distribution of env map luminance\n  // y channel is partial probability density of env map luminance\n  vec2 s0 = texelFetch(envMapDistribution, ivec2(0, vOffset), 0).xy;\n  vec2 s1 = texelFetch(envMapDistribution, ivec2(0, vOffset + 1), 0).xy;\n\n  pdf = s0.y;\n\n  return (float(vOffset) +  (u - s0.x) / (s1.x - s0.x)) / float(size.y);\n}\n\nfloat getEnvmapU(float u, int vOffset, out float pdf) {\n  ivec2 size = textureSize(envMap, 0);\n\n  int left = 0;\n  int right = size.x + 1; // cdf length is the length of the env map + 1\n  while (left < right) {\n    int mid = (left + right) >> 1;\n    float s = texelFetch(envMapDistribution, ivec2(1 + mid, vOffset), 0).x;\n    if (s <= u) {\n      left = mid + 1;\n    } else {\n      right = mid;\n    }\n  }\n  int uOffset = left - 1;\n\n  // x channel is cumulative distribution of env map luminance\n  // y channel is partial probability density of env map luminance\n  vec2 s0 = texelFetch(envMapDistribution, ivec2(1 + uOffset, vOffset), 0).xy;\n  vec2 s1 = texelFetch(envMapDistribution, ivec2(1 + uOffset + 1, vOffset), 0).xy;\n\n  pdf = s0.y;\n\n  return (float(uOffset) + (u - s0.x) / (s1.x - s0.x)) / float(size.x);\n}\n\n// Perform two binary searches to find light direction.\nvec3 sampleEnvmap(vec2 random, out vec2 uv, out float pdf) {\n  vec2 partialPdf;\n  int vOffset;\n\n  uv.y = getEnvmapV(random.x, vOffset, partialPdf.y);\n  uv.x = getEnvmapU(random.y, vOffset, partialPdf.x);\n\n  float phi = uv.x * TWOPI;\n  float theta = uv.y * PI;\n  float cosTheta = cos(theta);\n  float sinTheta = sin(theta);\n  float cosPhi = cos(phi);\n  float sinPhi = sin(phi);\n\n  vec3 dir = vec3(-sinTheta * cosPhi, cosTheta, -sinTheta * sinPhi);\n\n  pdf = partialPdf.x * partialPdf.y * INVPI2 / (2.0 * sinTheta);\n\n  return environmentRotation * dir;\n}\n\nfloat envMapPdf(vec2 uv) {\n  vec2 size = vec2(textureSize(envMap, 0));\n\n  float sinTheta = sin(uv.y * PI);\n\n  uv *= size;\n\n  float partialX = texelFetch(envMapDistribution, ivec2(1.0 + uv.x, uv.y), 0).y;\n  float partialY = texelFetch(envMapDistribution, ivec2(0, uv.y), 0).y;\n\n  return partialX * partialY * INVPI2 / (2.0 * sinTheta);\n}\n\nfloat groundedSurfaceDistance(vec3 point, float height, float radius) {\n  float pointLength = length(point);\n  if (pointLength < 0.00001) {\n    return -radius;\n  }\n\n  float originalY = radius * point.y / pointLength;\n  float transitionY = -1.5 * height;\n  float surfaceRadius;\n  if (originalY >= 0.0) {\n    surfaceRadius = radius;\n  } else if (originalY < transitionY) {\n    surfaceRadius = -height * pointLength / point.y;\n  } else {\n    float factor = 1.0\n      - originalY * originalY / (3.0 * transitionY * transitionY);\n    surfaceRadius = radius * factor;\n  }\n  return pointLength - surfaceRadius;\n}\n\nvec3 groundedBackgroundDirection(vec3 origin, vec3 d) {\n#ifdef USE_GROUNDED_BACKGROUND\n  float height = groundedBackgroundParams.x;\n  float radius = groundedBackgroundParams.y;\n  float groundY = groundedBackgroundParams.z;\n  vec3 rayDirection = normalize(d);\n  vec3 localOrigin = origin - vec3(\n    groundedBackgroundCenter.x,\n    groundY + height,\n    groundedBackgroundCenter.y\n  );\n\n  // The grounded skybox is a deformed sphere. Find the point where the ray\n  // exits that surface so its texture lookup matches the rasterized geometry.\n  float projectedOrigin = dot(localOrigin, rayDirection);\n  float discriminant = projectedOrigin * projectedOrigin\n    - dot(localOrigin, localOrigin) + radius * radius;\n  if (discriminant > 0.0) {\n    float farDistance = -projectedOrigin + sqrt(discriminant);\n    if (\n      farDistance > 0.0\n      && groundedSurfaceDistance(localOrigin, height, radius) <= 0.0\n    ) {\n      vec3 sphereHit = localOrigin + rayDirection * farDistance;\n      if (sphereHit.y >= 0.0) {\n        return normalize(sphereHit);\n      }\n\n      if (rayDirection.y < -0.00001 && radius > 1.5 * height) {\n        float groundDistance = (-height - localOrigin.y) / rayDirection.y;\n        vec3 groundHit = localOrigin + rayDirection * groundDistance;\n        float groundRadius = (2.0 / 3.0)\n          * sqrt(radius * radius - 2.25 * height * height);\n        if (groundDistance > 0.0 && length(groundHit.xz) <= groundRadius) {\n          return normalize(groundHit);\n        }\n      }\n\n      float nearDistance = 0.0;\n      for (int i = 0; i < 14; i++) {\n        float middleDistance = (nearDistance + farDistance) * 0.5;\n        vec3 middlePoint = localOrigin + rayDirection * middleDistance;\n        if (groundedSurfaceDistance(middlePoint, height, radius) > 0.0) {\n          farDistance = middleDistance;\n        } else {\n          nearDistance = middleDistance;\n        }\n      }\n      vec3 hit = localOrigin + rayDirection * ((nearDistance + farDistance) * 0.5);\n      return normalize(hit);\n    }\n  }\n#endif\n  return d;\n}\n\nvec4 sampleBackgroundFromRay(vec3 origin, vec3 d) {\n  d = groundedBackgroundDirection(origin, d);\n#ifdef USE_BACKGROUND\n  vec4 t = backgroundMapTransform;\n  d = vec3(t.x * d.x - t.y * d.z, d.y, t.y * d.x + t.x * d.z);\n  vec4 backgroundSample = textureLinear(backgroundMap, cartesianToEquirect(d));\n  return vec4(backgroundSample.rgb * t.z, backgroundSample.a);\n#else\n  return textureLinear(backgroundMap, environmentUv(d));\n#endif\n}`\n});\n"]}
+{"version":3,"file":"envMap.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/envMap.glsl.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,sFAAsF;AACtF,uHAAuH;AAEvH,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAElE,eAAe,iBAAiB,CAAC;IAC/B,QAAQ,EAAE;QACR,mBAAmB,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAE,CAAC,EAAC,CAAC,EAAC,CAAC,EAAE,CAAC,EAAC,CAAC,EAAC,CAAC,CAAC,CAAC;QAClE,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QACnC,kBAAkB,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QAC/C,aAAa,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QAC1C,sBAAsB,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,CAAC,CAAC;QACzD,qBAAqB,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAE,CAAC,EAAC,CAAC,EAAC,CAAC,EAAE,CAAC,EAAC,CAAC,EAAC,CAAC,CAAC,CAAC;QACpE,wBAAwB,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;QAChD,wBAAwB,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;KACjD;IACD,IAAI,EAAE,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8LV;CACD,CAAC,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// Sample the environment map using a cumulative distribution function as described in\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Sampling_Light_Sources.html#InfiniteAreaLights\n\nimport { createShaderMixin, glsl, Shader } from '../../shader.js';\n\nexport default createShaderMixin({\n  uniforms: {\n    environmentRotation: Shader.uniform('mat3', [1,0,0, 0,1,0, 0,0,1]),\n    envMap: Shader.uniform('sampler2D'),\n    envMapDistribution: Shader.uniform('sampler2D'),\n    backgroundMap: Shader.uniform('sampler2D'),\n    backgroundMapTransform: Shader.uniform('vec4', [1,0,1,0]),\n    backgroundMapRotation: Shader.uniform('mat3', [1,0,0, 0,1,0, 0,0,1]),\n    groundedBackgroundParams: Shader.uniform('vec4'),\n    groundedBackgroundCenter: Shader.uniform('vec2')\n  },\n  main: glsl`\nvec2 cartesianToEquirect(vec3 pointOnSphere) {\n  float phi = mod(atan(-pointOnSphere.z, -pointOnSphere.x), TWOPI);\n  float theta = acos(clamp(pointOnSphere.y, -1.0, 1.0));\n  return vec2(phi * 0.5 * INVPI, theta * INVPI);\n}\n\nvec2 environmentUv(vec3 worldDirection) {\n  return cartesianToEquirect(transpose(environmentRotation) * worldDirection);\n}\n\nfloat getEnvmapV(float u, out int vOffset, out float pdf) {\n  ivec2 size = textureSize(envMap, 0);\n\n  int left = 0;\n  int right = size.y + 1; // cdf length is the length of the env map + 1\n  while (left < right) {\n    int mid = (left + right) >> 1;\n    float s = texelFetch(envMapDistribution, ivec2(0, mid), 0).x;\n    if (s <= u) {\n      left = mid + 1;\n    } else {\n      right = mid;\n    }\n  }\n  vOffset = left - 1;\n\n  // x channel is cumulative distribution of env map luminance\n  // y channel is partial probability density of env map luminance\n  vec2 s0 = texelFetch(envMapDistribution, ivec2(0, vOffset), 0).xy;\n  vec2 s1 = texelFetch(envMapDistribution, ivec2(0, vOffset + 1), 0).xy;\n\n  pdf = s0.y;\n\n  return (float(vOffset) +  (u - s0.x) / (s1.x - s0.x)) / float(size.y);\n}\n\nfloat getEnvmapU(float u, int vOffset, out float pdf) {\n  ivec2 size = textureSize(envMap, 0);\n\n  int left = 0;\n  int right = size.x + 1; // cdf length is the length of the env map + 1\n  while (left < right) {\n    int mid = (left + right) >> 1;\n    float s = texelFetch(envMapDistribution, ivec2(1 + mid, vOffset), 0).x;\n    if (s <= u) {\n      left = mid + 1;\n    } else {\n      right = mid;\n    }\n  }\n  int uOffset = left - 1;\n\n  // x channel is cumulative distribution of env map luminance\n  // y channel is partial probability density of env map luminance\n  vec2 s0 = texelFetch(envMapDistribution, ivec2(1 + uOffset, vOffset), 0).xy;\n  vec2 s1 = texelFetch(envMapDistribution, ivec2(1 + uOffset + 1, vOffset), 0).xy;\n\n  pdf = s0.y;\n\n  return (float(uOffset) + (u - s0.x) / (s1.x - s0.x)) / float(size.x);\n}\n\n// Match the WGSL pole convention and keep the Jacobian positive in f32.\nfloat envMapSolidAnglePdf(vec2 partialPdf, float v) {\n  if (!(v > 0.0 && v < 1.0)) { return 0.0; }\n  float sinTheta = sin(min(v, 1.0 - v) * PI);\n  return partialPdf.x * partialPdf.y * INVPI2 / (2.0 * sinTheta);\n}\n\n// Perform two binary searches to find light direction.\nvec3 sampleEnvmap(vec2 random, out vec2 uv, out float pdf) {\n  vec2 partialPdf;\n  int vOffset;\n\n  uv.y = getEnvmapV(random.x, vOffset, partialPdf.y);\n  uv.x = getEnvmapU(random.y, vOffset, partialPdf.x);\n\n  float phi = uv.x * TWOPI;\n  float theta = uv.y * PI;\n  float cosTheta = cos(theta);\n  float sinTheta = sin(theta);\n  float cosPhi = cos(phi);\n  float sinPhi = sin(phi);\n\n  vec3 dir = vec3(-sinTheta * cosPhi, cosTheta, -sinTheta * sinPhi);\n\n  pdf = envMapSolidAnglePdf(partialPdf, uv.y);\n\n  return environmentRotation * dir;\n}\n\nfloat envMapPdf(vec2 uv) {\n  vec2 size = vec2(textureSize(envMap, 0));\n\n  ivec2 pixel = clamp(ivec2(uv * size), ivec2(0), ivec2(size) - ivec2(1));\n\n  float partialX = texelFetch(envMapDistribution, ivec2(1 + pixel.x, pixel.y), 0).y;\n  float partialY = texelFetch(envMapDistribution, ivec2(0, pixel.y), 0).y;\n\n  return envMapSolidAnglePdf(vec2(partialX, partialY), uv.y);\n}\n\nfloat groundedSurfaceDistance(vec3 point, float height, float radius) {\n  float pointLength = length(point);\n  if (pointLength < 0.00001) {\n    return -radius;\n  }\n\n  float originalY = radius * point.y / pointLength;\n  float transitionY = -1.5 * height;\n  float surfaceRadius;\n  if (originalY >= 0.0) {\n    surfaceRadius = radius;\n  } else if (originalY < transitionY) {\n    surfaceRadius = -height * pointLength / point.y;\n  } else {\n    float factor = 1.0\n      - originalY * originalY / (3.0 * transitionY * transitionY);\n    surfaceRadius = radius * factor;\n  }\n  return pointLength - surfaceRadius;\n}\n\nvec3 groundedBackgroundDirection(vec3 origin, vec3 d) {\n#ifdef USE_GROUNDED_BACKGROUND\n  float height = groundedBackgroundParams.x;\n  float radius = groundedBackgroundParams.y;\n  float groundY = groundedBackgroundParams.z;\n  vec3 rayDirection = normalize(d);\n  vec3 localOrigin = origin - vec3(\n    groundedBackgroundCenter.x,\n    groundY + height,\n    groundedBackgroundCenter.y\n  );\n\n  // The grounded skybox is a deformed sphere. Find the point where the ray\n  // exits that surface so its texture lookup matches the rasterized geometry.\n  float projectedOrigin = dot(localOrigin, rayDirection);\n  float discriminant = projectedOrigin * projectedOrigin\n    - dot(localOrigin, localOrigin) + radius * radius;\n  if (discriminant > 0.0) {\n    float farDistance = -projectedOrigin + sqrt(discriminant);\n    if (\n      farDistance > 0.0\n      && groundedSurfaceDistance(localOrigin, height, radius) <= 0.0\n    ) {\n      vec3 sphereHit = localOrigin + rayDirection * farDistance;\n      if (sphereHit.y >= 0.0) {\n        return normalize(sphereHit);\n      }\n\n      if (rayDirection.y < -0.00001 && radius > 1.5 * height) {\n        float groundDistance = (-height - localOrigin.y) / rayDirection.y;\n        vec3 groundHit = localOrigin + rayDirection * groundDistance;\n        float groundRadius = (2.0 / 3.0)\n          * sqrt(radius * radius - 2.25 * height * height);\n        if (groundDistance > 0.0 && length(groundHit.xz) <= groundRadius) {\n          return normalize(groundHit);\n        }\n      }\n\n      float nearDistance = 0.0;\n      for (int i = 0; i < 14; i++) {\n        float middleDistance = (nearDistance + farDistance) * 0.5;\n        vec3 middlePoint = localOrigin + rayDirection * middleDistance;\n        if (groundedSurfaceDistance(middlePoint, height, radius) > 0.0) {\n          farDistance = middleDistance;\n        } else {\n          nearDistance = middleDistance;\n        }\n      }\n      vec3 hit = localOrigin + rayDirection * ((nearDistance + farDistance) * 0.5);\n      return normalize(hit);\n    }\n  }\n#endif\n  return d;\n}\n\nvec4 sampleBackgroundFromRay(vec3 origin, vec3 d) {\n  d = groundedBackgroundDirection(origin, d);\n#ifdef USE_BACKGROUND\n  vec4 t = backgroundMapTransform;\n  d = vec3(t.x * d.x - t.y * d.z, d.y, t.y * d.x + t.x * d.z);\n  vec4 backgroundSample = textureLinear(backgroundMap, cartesianToEquirect(transpose(backgroundMapRotation) * d));\n  return vec4(backgroundSample.rgb * t.z, backgroundSample.a);\n#else\n  return textureLinear(backgroundMap, environmentUv(d));\n#endif\n}`\n});\n"]}