@meimu/mutracer 0.1.4 → 0.2.0

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

@@ -1 +1 @@
-{"version":3,"file":"rayTraceCore.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/rayTraceCore.glsl.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE1D,eAAe,iBAAiB,CAAC;IAC/B,QAAQ,EAAE;QACR,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QACtC,cAAc,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QAC3C,iBAAiB,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;QAC3C,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;QACjC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;QAC9B,WAAW,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC;QAClC,oBAAoB,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;KACjD;IACD,OAAO,EAAE;QACP,QAAQ,EAAE,CAAC;QACX,KAAK,EAAE,aAAa;QACpB,cAAc,EAAE,qBAAqB;QACrC,UAAU,EAAE,mBAAmB;KAChC;IACD,IAAI,EAAE,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuQX;CACA,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\nimport { createShaderMixin, glsl, Shader } from '../../shader.js';\nimport { ShadowCatcherMaterial, UnlitMaterial } from '../../../constants.js';\nimport { CONSTANT_SPOT_LIGHT } from '../../lightsUtil.js';\n\nexport default createShaderMixin({\n  uniforms: {\n    lightsTex: Shader.uniform('sampler2D'),\n    iesProfileData: Shader.uniform('sampler2D'),\n    iesProfileColumns: Shader.uniform('int', 1),\n    pixelSize: Shader.uniform('vec2'),\n    jitter: Shader.uniform('vec2'),\n    sampleCount: Shader.uniform('int'),\n    envLightSelectionPmf: Shader.uniform('float', 0)\n  },\n  defines: {\n    STANDARD: 0,\n    UNLIT: UnlitMaterial,\n    SHADOW_CATCHER: ShadowCatcherMaterial,\n    SPOT_LIGHT: CONSTANT_SPOT_LIGHT\n  },\n  main: glsl`\n// https://www.w3.org/WAI/GL/wiki/Relative_luminance\nconst vec3 luminance = vec3(0.2126, 0.7152, 0.0722);\nconst int bounceSamples = 8;\n\n#define RAY_MAX_DISTANCE 9999.0\n\n#define NO_UNROLL(X) (X + min(0, sampleCount))\n#define NO_UNROLLU(X) (X + uint(min(0, sampleCount)))\n\nstruct Ray {\n  vec3 o;\n  vec3 d;\n  float tMax;\n};\n\nstruct SurfaceInteraction {\n  bool hit;\n  vec3 position;\n  vec3 normal; // material shading normal\n#ifdef NUM_COAT_NORMAL_MAPS\n  vec3 coatNormal;\n#endif\n  vec3 vertexNormal; // interpolated mesh normal before normal mapping\n  vec3 shadowOffset; // smooth-surface offset used by direct-light shadow rays\n  \n  vec2 uv;\n  vec2 uv1;\n  vec3 vertexColor;\n\n#ifdef USE_TANGENT\n  vec3 tangent;\n#endif\n  vec3 directionTangent;\n  vec3 directionBitangent;\n  vec3 geometryTangent;\n  vec3 geometryBitangent;\n  vec3 faceNormal; // normal of the triangle\n\n  bool isTransparency;\n  // For perfect specular or transmission surface\n  // We use the albedo and normal of first diffuse or glossy surface hit instead for denoising\n  // See albedo section in https://www.openimagedenoise.org/documentation.html\n  bool albedoSampled;\n\n  int triangleIndex;\n  int instanceIndex;\n  int materialIndex;\n\n  int mediumType;\n  vec3 mediumExtinction;\n  vec3 mediumScattering;\n  float mediumAnisotropy;\n};\n\n// Texture-resolved OpenPBR inputs used by the surface integrator. The storage\n// buffer keeps its compact legacy layout; getMaterial() is the compatibility\n// boundary that maps it to these canonical names.\nstruct OpenPbrResolvedMaterial {\n  int materialType;\n\n  float specularRoughness;\n  float baseMetalness;\n  vec3 baseColor;\n  float specularIor;\n  vec3 emission;\n  float transmissionWeight;\n  bool thinWalled;\n  float specularAnisotropy;\n  float alpha;\n\n  float transmissionDispersionScale;\n  float dispersionAbbeNumber;\n  float thinFilmThickness;\n  float thinFilmIor;\n  float thinFilmWeight;\n\n  // Medium\n  int mediumType;\n  vec3 mediumExtinction;\n  vec3 mediumScattering;\n  float mediumAnisotropy;\n\n  float baseWeight;\n  float diffuseRoughness;\n  float specularWeight;\n  vec3 specularColor;\n  float subsurfaceWeight;\n  vec3 subsurfaceColor;\n  vec3 transmissionColor;\n  float fuzzWeight;\n  vec3 fuzzColor;\n  float fuzzRoughness;\n  float coatWeight;\n  vec3 coatColor;\n  float coatRoughness;\n  float coatAnisotropy;\n  vec2 anisotropyDirection;\n  bool anisotropyDirectionEnabled;\n  float coatAnisotropyRotation;\n  vec3 directionTangent;\n  vec3 directionBitangent;\n  vec3 geometryTangent;\n  vec3 geometryBitangent;\n#ifdef NUM_COAT_NORMAL_MAPS\n  vec3 coatNormal;\n  bool coatNormalEnabled;\n  vec3 geometricNormal;\n#endif\n  float coatIor;\n  float coatDarkening;\n\n  float bevel;\n\n  // Calculated\n  float relativeIor;\n  bool inside;\n  float alphaX;\n  float alphaY;\n};\n\n\nstruct Light {\n  vec3 position;\n  vec3 emission;\n  vec3 u;\n  vec3 v;\n  float radius;\n  float area;\n  float type;\n  int textureIndex;\n  float spread;\n  float selectionPmf;\n  float selectionCdf;\n  vec3 iesReference;\n};\n\nvoid initRay(inout Ray ray, vec3 origin, vec3 direction) {\n  ray.o = origin;\n  ray.d = direction;\n  ray.tMax = RAY_MAX_DISTANCE;\n}\n\n// given the index from a 1D array, retrieve corresponding position from packed 2D texture\nivec2 unpackTexel(int i, int columnsLog2) {\n  ivec2 u;\n  u.y = i >> columnsLog2; // equivalent to (i / 2^columnsLog2)\n  u.x = i - (u.y << columnsLog2); // equivalent to (i % 2^columnsLog2)\n  return u;\n}\n\nvec4 fetchData(sampler2D s, int i, int columnsLog2) {\n  return texelFetch(s, unpackTexel(i, columnsLog2), 0);\n}\n\nivec4 fetchData(highp isampler2D s, int i, int columnsLog2) {\n  return texelFetch(s, unpackTexel(i, columnsLog2), 0);\n}\n\nstruct Path {\n  Ray ray;\n  vec3 li;\n  float alpha;\n  vec3 beta;\n  bool fromEye;\n  bool abort;\n  float scatteringPdf;\n  bool scatteringIsDelta;\n  bool isNextRefraction;\n};\n\nstruct LightSampleRec {\n  vec3 normal;\n  vec3 emission;\n  vec3 direction;\n  float dist;\n  float pdf;\n  bool isDelta;\n};\n\n\nLight fetchLight(int i) {\n  int firstTexel = i * 6;\n  vec4 positionAndPmf = texelFetch(\n    lightsTex,\n    ivec2(firstTexel, 0),\n    0\n  );\n  vec4 emissionAndCdf = texelFetch(\n    lightsTex,\n    ivec2(firstTexel + 1, 0),\n    0\n  );\n  vec4 tangentAndSpread = texelFetch(\n    lightsTex,\n    ivec2(firstTexel + 2, 0),\n    0\n  );\n  vec4 bitangentAndTexture = texelFetch(\n    lightsTex,\n    ivec2(firstTexel + 3, 0),\n    0\n  );\n  vec4 shape = texelFetch(\n    lightsTex,\n    ivec2(firstTexel + 4, 0),\n    0\n  );\n  return Light(\n    positionAndPmf.xyz,\n    emissionAndCdf.xyz,\n    tangentAndSpread.xyz,\n    bitangentAndTexture.xyz,\n    shape.x,\n    shape.y,\n    shape.z,\n    int(bitangentAndTexture.w),\n    tangentAndSpread.w,\n    positionAndPmf.w,\n    emissionAndCdf.w,\n    texelFetch(lightsTex, ivec2(firstTexel + 5, 0), 0).xyz\n  );\n}\n\nfloat iesProfileScalar(int baseTexel, int scalarIndex) {\n  int texelIndex = baseTexel + scalarIndex / 4;\n  vec4 packed = texelFetch(\n    iesProfileData,\n    ivec2(texelIndex % iesProfileColumns, texelIndex / iesProfileColumns),\n    0\n  );\n  return packed[scalarIndex % 4];\n}\n\nfloat sampleIESProfile(int baseTexel, vec2 uv) {\n  if (baseTexel < 0) return 1.0;\n  vec2 pixel = fract(uv) * 128.0 - 0.5;\n  ivec2 p0 = ivec2(floor(pixel));\n  vec2 f = fract(pixel);\n  int xa = p0.x < 0 ? 127 : p0.x;\n  int xb = p0.x >= 127 ? 0 : p0.x + 1;\n  int ya = p0.y < 0 ? 127 : p0.y;\n  int yb = p0.y >= 127 ? 0 : p0.y + 1;\n  float a = iesProfileScalar(baseTexel, ya * 128 + xa);\n  float b = iesProfileScalar(baseTexel, ya * 128 + xb);\n  float c = iesProfileScalar(baseTexel, yb * 128 + xa);\n  float d = iesProfileScalar(baseTexel, yb * 128 + xb);\n  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);\n}\n\nfloat evaluateSpotEmissionMultiplier(Light light, vec3 lightToSurface) {\n  vec3 axis = normalize(light.u);\n  float cosTheta = dot(axis, lightToSurface);\n  float cone = light.v.y > light.v.x + 1e-6\n    ? smoothstep(light.v.x, light.v.y, cosTheta)\n    : step(light.v.x, cosTheta);\n  if (cone <= 0.0 || light.textureIndex < 0) return cone;\n  vec3 xAxis = light.iesReference;\n  vec3 yAxis = cross(axis, xAxis);\n  float vertical = acos(clamp(cosTheta, -1.0, 1.0));\n  float horizontal = atan(dot(lightToSurface, yAxis), dot(lightToSurface, xAxis));\n  return cone * sampleIESProfile(light.textureIndex, vec2(vertical / PI, horizontal / TWOPI + 0.5));\n}\n`\n});\n"]}
+{"version":3,"file":"rayTraceCore.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/rayTraceCore.glsl.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D,eAAe,iBAAiB,CAAC;IAC/B,QAAQ,EAAE;QACR,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QACtC,cAAc,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QAC3C,iBAAiB,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;QAC3C,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;QACjC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;QAC9B,WAAW,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC;QAClC,oBAAoB,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;KACjD;IACD,OAAO,EAAE;QACP,QAAQ,EAAE,CAAC;QACX,KAAK,EAAE,aAAa;QACpB,cAAc,EAAE,qBAAqB;QACrC,UAAU,EAAE,mBAAmB;KAChC;IACD,IAAI,EAAE,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuQX;CACA,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\nimport { createShaderMixin, glsl, Shader } from '../../shader.js';\nimport { ShadowCatcherMaterial, UnlitMaterial } from '../../../constants.js';\nimport { CONSTANT_SPOT_LIGHT } from '../../lightConstants.js';\n\nexport default createShaderMixin({\n  uniforms: {\n    lightsTex: Shader.uniform('sampler2D'),\n    iesProfileData: Shader.uniform('sampler2D'),\n    iesProfileColumns: Shader.uniform('int', 1),\n    pixelSize: Shader.uniform('vec2'),\n    jitter: Shader.uniform('vec2'),\n    sampleCount: Shader.uniform('int'),\n    envLightSelectionPmf: Shader.uniform('float', 0)\n  },\n  defines: {\n    STANDARD: 0,\n    UNLIT: UnlitMaterial,\n    SHADOW_CATCHER: ShadowCatcherMaterial,\n    SPOT_LIGHT: CONSTANT_SPOT_LIGHT\n  },\n  main: glsl`\n// https://www.w3.org/WAI/GL/wiki/Relative_luminance\nconst vec3 luminance = vec3(0.2126, 0.7152, 0.0722);\nconst int bounceSamples = 8;\n\n#define RAY_MAX_DISTANCE 9999.0\n\n#define NO_UNROLL(X) (X + min(0, sampleCount))\n#define NO_UNROLLU(X) (X + uint(min(0, sampleCount)))\n\nstruct Ray {\n  vec3 o;\n  vec3 d;\n  float tMax;\n};\n\nstruct SurfaceInteraction {\n  bool hit;\n  vec3 position;\n  vec3 normal; // material shading normal\n#ifdef USE_COAT_NORMAL_FRAMES\n  vec3 coatNormal;\n#endif\n  vec3 vertexNormal; // interpolated mesh normal before normal mapping\n  vec3 shadowOffset; // smooth-surface offset used by direct-light shadow rays\n  \n  vec2 uv;\n  vec2 uv1;\n  vec3 vertexColor;\n\n#ifdef USE_TANGENT\n  vec3 tangent;\n#endif\n  vec3 directionTangent;\n  vec3 directionBitangent;\n  vec3 geometryTangent;\n  vec3 geometryBitangent;\n  vec3 faceNormal; // normal of the triangle\n\n  bool isTransparency;\n  // For perfect specular or transmission surface\n  // We use the albedo and normal of first diffuse or glossy surface hit instead for denoising\n  // See albedo section in https://www.openimagedenoise.org/documentation.html\n  bool albedoSampled;\n\n  int triangleIndex;\n  int instanceIndex;\n  int materialIndex;\n\n  int mediumType;\n  vec3 mediumExtinction;\n  vec3 mediumScattering;\n  float mediumAnisotropy;\n};\n\n// Texture-resolved OpenPBR inputs used by the surface integrator. The storage\n// buffer keeps its compact legacy layout; getMaterial() is the compatibility\n// boundary that maps it to these canonical names.\nstruct OpenPbrResolvedMaterial {\n  int materialType;\n\n  float specularRoughness;\n  float baseMetalness;\n  vec3 baseColor;\n  float specularIor;\n  vec3 emission;\n  float transmissionWeight;\n  bool thinWalled;\n  float specularAnisotropy;\n  float alpha;\n\n  float transmissionDispersionScale;\n  float dispersionAbbeNumber;\n  float thinFilmThickness;\n  float thinFilmIor;\n  float thinFilmWeight;\n\n  // Medium\n  int mediumType;\n  vec3 mediumExtinction;\n  vec3 mediumScattering;\n  float mediumAnisotropy;\n\n  float baseWeight;\n  float diffuseRoughness;\n  float specularWeight;\n  vec3 specularColor;\n  float subsurfaceWeight;\n  vec3 subsurfaceColor;\n  vec3 transmissionColor;\n  float fuzzWeight;\n  vec3 fuzzColor;\n  float fuzzRoughness;\n  float coatWeight;\n  vec3 coatColor;\n  float coatRoughness;\n  float coatAnisotropy;\n  vec2 anisotropyDirection;\n  bool anisotropyDirectionEnabled;\n  float coatAnisotropyRotation;\n  vec3 directionTangent;\n  vec3 directionBitangent;\n  vec3 geometryTangent;\n  vec3 geometryBitangent;\n#ifdef USE_COAT_NORMAL_FRAMES\n  vec3 coatNormal;\n  bool coatNormalEnabled;\n  vec3 geometricNormal;\n#endif\n  float coatIor;\n  float coatDarkening;\n\n  float bevel;\n\n  // Calculated\n  float relativeIor;\n  bool inside;\n  float alphaX;\n  float alphaY;\n};\n\n\nstruct Light {\n  vec3 position;\n  vec3 emission;\n  vec3 u;\n  vec3 v;\n  float radius;\n  float area;\n  float type;\n  int textureIndex;\n  float spread;\n  float selectionPmf;\n  float selectionCdf;\n  vec3 iesReference;\n};\n\nvoid initRay(inout Ray ray, vec3 origin, vec3 direction) {\n  ray.o = origin;\n  ray.d = direction;\n  ray.tMax = RAY_MAX_DISTANCE;\n}\n\n// given the index from a 1D array, retrieve corresponding position from packed 2D texture\nivec2 unpackTexel(int i, int columnsLog2) {\n  ivec2 u;\n  u.y = i >> columnsLog2; // equivalent to (i / 2^columnsLog2)\n  u.x = i - (u.y << columnsLog2); // equivalent to (i % 2^columnsLog2)\n  return u;\n}\n\nvec4 fetchData(sampler2D s, int i, int columnsLog2) {\n  return texelFetch(s, unpackTexel(i, columnsLog2), 0);\n}\n\nivec4 fetchData(highp isampler2D s, int i, int columnsLog2) {\n  return texelFetch(s, unpackTexel(i, columnsLog2), 0);\n}\n\nstruct Path {\n  Ray ray;\n  vec3 li;\n  float alpha;\n  vec3 beta;\n  bool fromEye;\n  bool abort;\n  float scatteringPdf;\n  bool scatteringIsDelta;\n  bool isNextRefraction;\n};\n\nstruct LightSampleRec {\n  vec3 normal;\n  vec3 emission;\n  vec3 direction;\n  float dist;\n  float pdf;\n  bool isDelta;\n};\n\n\nLight fetchLight(int i) {\n  int firstTexel = i * 6;\n  vec4 positionAndPmf = texelFetch(\n    lightsTex,\n    ivec2(firstTexel, 0),\n    0\n  );\n  vec4 emissionAndCdf = texelFetch(\n    lightsTex,\n    ivec2(firstTexel + 1, 0),\n    0\n  );\n  vec4 tangentAndSpread = texelFetch(\n    lightsTex,\n    ivec2(firstTexel + 2, 0),\n    0\n  );\n  vec4 bitangentAndTexture = texelFetch(\n    lightsTex,\n    ivec2(firstTexel + 3, 0),\n    0\n  );\n  vec4 shape = texelFetch(\n    lightsTex,\n    ivec2(firstTexel + 4, 0),\n    0\n  );\n  return Light(\n    positionAndPmf.xyz,\n    emissionAndCdf.xyz,\n    tangentAndSpread.xyz,\n    bitangentAndTexture.xyz,\n    shape.x,\n    shape.y,\n    shape.z,\n    int(bitangentAndTexture.w),\n    tangentAndSpread.w,\n    positionAndPmf.w,\n    emissionAndCdf.w,\n    texelFetch(lightsTex, ivec2(firstTexel + 5, 0), 0).xyz\n  );\n}\n\nfloat iesProfileScalar(int baseTexel, int scalarIndex) {\n  int texelIndex = baseTexel + scalarIndex / 4;\n  vec4 packed = texelFetch(\n    iesProfileData,\n    ivec2(texelIndex % iesProfileColumns, texelIndex / iesProfileColumns),\n    0\n  );\n  return packed[scalarIndex % 4];\n}\n\nfloat sampleIESProfile(int baseTexel, vec2 uv) {\n  if (baseTexel < 0) return 1.0;\n  vec2 pixel = fract(uv) * 128.0 - 0.5;\n  ivec2 p0 = ivec2(floor(pixel));\n  vec2 f = fract(pixel);\n  int xa = p0.x < 0 ? 127 : p0.x;\n  int xb = p0.x >= 127 ? 0 : p0.x + 1;\n  int ya = p0.y < 0 ? 127 : p0.y;\n  int yb = p0.y >= 127 ? 0 : p0.y + 1;\n  float a = iesProfileScalar(baseTexel, ya * 128 + xa);\n  float b = iesProfileScalar(baseTexel, ya * 128 + xb);\n  float c = iesProfileScalar(baseTexel, yb * 128 + xa);\n  float d = iesProfileScalar(baseTexel, yb * 128 + xb);\n  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);\n}\n\nfloat evaluateSpotEmissionMultiplier(Light light, vec3 lightToSurface) {\n  vec3 axis = normalize(light.u);\n  float cosTheta = dot(axis, lightToSurface);\n  float cone = light.v.y > light.v.x + 1e-6\n    ? smoothstep(light.v.x, light.v.y, cosTheta)\n    : step(light.v.x, cosTheta);\n  if (cone <= 0.0 || light.textureIndex < 0) return cone;\n  vec3 xAxis = light.iesReference;\n  vec3 yAxis = cross(axis, xAxis);\n  float vertical = acos(clamp(cosTheta, -1.0, 1.0));\n  float horizontal = atan(dot(lightToSurface, yAxis), dot(lightToSurface, xAxis));\n  return cone * sampleIESProfile(light.textureIndex, vec2(vertical / PI, horizontal / TWOPI + 0.5));\n}\n`\n});\n"]}

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

@@ -1,16 +1,16 @@
 import { glsl } from '../../shader.js';
 export default glsl `
 #ifdef NUM_LIGHTS
-void eM(
+void eY(
 in Light light,
 in vec3 shadingPoint,
 in vec2 samplePoint,
 inout LightSampleRec result
 ) {
-vec3 nS = light.position - shadingPoint;
-float aj = length(nS);
+vec3 oN = light.position - shadingPoint;
+float ak = length(oN);
 if (light.radius <= 0.0) {
-if (aj <= 1e-6) {
+if (ak <= 1e-6) {
 result.direction = vec3(0.0, 0.0, 1.0);
 result.normal = vec3(0.0, 0.0, -1.0);
 result.dist = 0.0;
@@ -19,11 +19,11 @@ result.emission = vec3(0.0);
 result.isDelta = true;
 return;
 }
-result.direction = nS / aj;
+result.direction = oN / ak;
 result.normal = -result.direction;
-result.dist = aj;
+result.dist = ak;
 result.pdf = 1.0;
-result.emission = light.emission / max(aj * aj, 1e-8);
+result.emission = light.emission / max(ak * ak, 1e-8);
 result.isDelta = true;
 return;
 }
@@ -31,46 +31,46 @@ float radius = max(light.radius, 1e-6);
 result.isDelta = false;
 vec3 direction;
 
-if (aj <= radius) {
+if (ak <= radius) {
 float z = 1.0 - 2.0 * samplePoint.x;
-float fl = sqrt(max(0.0, 1.0 - z * z));
-float br = TWOPI * samplePoint.y;
-direction = vec3(fl * cos(br), fl * sin(br), z);
+float ex = sqrt(max(0.0, 1.0 - z * z));
+float azimuth = TWOPI * samplePoint.y;
+direction = vec3(ex * cos(azimuth), ex * sin(azimuth), z);
 result.pdf = INV4PI;
 }
 else {
-vec3 axis = nS / aj;
-float rT = min(
+vec3 axis = oN / ak;
+float sX = min(
 1.0,
-radius * radius / (aj * aj)
+radius * radius / (ak * ak)
 );
-float rW = sqrt(max(0.0, 1.0 - rT));
-float au = mix(1.0, rW, samplePoint.x);
-float ud = sqrt(max(0.0, 1.0 - au * au));
-float br = TWOPI * samplePoint.y;
+float tc = sqrt(max(0.0, 1.0 - sX));
+float cosine = mix(1.0, tc, samplePoint.x);
+float vF = sqrt(max(0.0, 1.0 - cosine * cosine));
+float azimuth = TWOPI * samplePoint.y;
 vec3 tangent;
 vec3 bitangent;
-aL(axis, tangent, bitangent);
-direction = axis * au
-+ tangent * (ud * cos(br))
-+ bitangent * (ud * sin(br));
-result.pdf = 1.0 / max(TWOPI * (1.0 - rW), 1e-8);
+aP(axis, tangent, bitangent);
+direction = axis * cosine
++ tangent * (vF * cos(azimuth))
++ bitangent * (vF * sin(azimuth));
+result.pdf = 1.0 / max(TWOPI * (1.0 - tc), 1e-8);
 }
 
-float jf = dot(direction, nS);
-float ej = jf * jf
-- dot(nS, nS) + radius * radius;
-float wK = sqrt(max(0.0, ej));
-float cN = jf - wK;
-float cC = jf + wK;
-result.dist = cN > 1e-6 ? cN : cC;
+float jC = dot(direction, oN);
+float br = jC * jC
+- dot(oN, oN) + radius * radius;
+float yn = sqrt(max(0.0, br));
+float cV = jC - yn;
+float cM = jC + yn;
+result.dist = cV > 1e-6 ? cV : cM;
 result.direction = direction;
 vec3 surfacePoint = shadingPoint + direction * result.dist;
 result.normal = normalize(surfacePoint - light.position);
 result.emission = light.emission;
 }
 
-void da(
+void dn(
 in Light light,
 in vec3 surfacePoint,
 in vec3 lowerLeft,
@@ -80,17 +80,17 @@ inout LightSampleRec result
 if (light.textureIndex >= 0) {
 float width = length(light.u);
 float height = length(light.v);
-vec3 ib = surfacePoint - lowerLeft;
+vec3 ek = surfacePoint - lowerLeft;
 vec2 uv = vec2(
-dot(ib, light.u / width) / width,
-dot(ib, light.v / height) / height
+dot(ek, light.u / width) / width,
+dot(ek, light.v / height) / height
 );
 result.emission *= sampleMap(light.textureIndex, uv).rgb;
 }
 #endif
 }
 
-void jS(
+void kw(
 in Light light,
 in vec3 shadingPoint,
 in vec2 samplePoint,
@@ -101,28 +101,28 @@ vec3 lowerLeft = light.position - 0.5 * (light.u + light.v);
 float spread = clamp(light.spread, 0.0, 1.0);
 
 if (spread <= 0.001) {
-float gf = dot(normal, shadingPoint - light.position);
-vec3 surfacePoint = shadingPoint - normal * gf;
-vec3 ib = surfacePoint - lowerLeft;
+float gw = dot(normal, shadingPoint - light.position);
+vec3 surfacePoint = shadingPoint - normal * gw;
+vec3 ek = surfacePoint - lowerLeft;
 float width = length(light.u);
 float height = length(light.v);
 vec2 uv = vec2(
-dot(ib, light.u / width) / width,
-dot(ib, light.v / height) / height
+dot(ek, light.u / width) / width,
+dot(ek, light.v / height) / height
 );
-if (gf <= 0.0 || any(lessThan(uv, vec2(0.0)))
+if (gw <= 0.0 || any(lessThan(uv, vec2(0.0)))
 || any(greaterThan(uv, vec2(1.0)))) {
 result.emission = vec3(0.0);
 result.pdf = 0.0;
 return;
 }
 result.direction = -normal;
-result.dist = gf;
+result.dist = gw;
 result.normal = normal;
 result.emission = light.emission;
 result.pdf = 1.0;
 result.isDelta = true;
-da(light, surfacePoint, lowerLeft, result);
+dn(light, surfacePoint, lowerLeft, result);
 return;
 }
 
@@ -130,23 +130,23 @@ vec3 surfacePoint = lowerLeft
 + light.u * samplePoint.x
 + light.v * samplePoint.y;
 vec3 offset = surfacePoint - shadingPoint;
-float hq = dot(offset, offset);
-result.dist = sqrt(hq);
+float hE = dot(offset, offset);
+result.dist = sqrt(hE);
 result.direction = offset / result.dist;
 result.normal = normal;
-float fZ = dot(-result.direction, normal);
-float oO = cos(0.5 * PI * spread);
-if (fZ <= 0.0 || fZ < oO) {
+float gn = dot(-result.direction, normal);
+float pK = cos(0.5 * PI * spread);
+if (gn <= 0.0 || gn < pK) {
 result.emission = vec3(0.0);
 result.pdf = 0.0;
 return;
 }
 result.emission = light.emission;
-result.pdf = hq / max(light.area * fZ, 1e-8);
-da(light, surfacePoint, lowerLeft, result);
+result.pdf = hE / max(light.area * gn, 1e-8);
+dn(light, surfacePoint, lowerLeft, result);
 }
 
-void gc(
+void gs(
 in Light light,
 in vec3 shadingPoint,
 inout LightSampleRec result
@@ -159,56 +159,56 @@ result.pdf = 1.0;
 result.isDelta = true;
 }
 
-void jT(
+void kx(
 in Light light,
 in vec3 shadingPoint,
 in vec2 samplePoint,
 inout LightSampleRec result
 ) {
-eM(light, shadingPoint, samplePoint, result);
+eY(light, shadingPoint, samplePoint, result);
 vec3 surfacePoint = shadingPoint + result.direction * result.dist;
-result.emission *= bL(
+result.emission *= bP(
 light,
 normalize(shadingPoint - surfacePoint)
 );
 }
 
-void iQ(
+void jg(
 in Light light,
 in vec3 shadingPoint,
 in vec2 samplePoint,
 inout LightSampleRec result
 ) {
-int dP = int(light.type);
+int ec = int(light.type);
 #ifdef HAS_RECT_LIGHTS
-if (dP == RECT_LIGHT) {
-jS(light, shadingPoint, samplePoint, result);
+if (ec == RECT_LIGHT) {
+kw(light, shadingPoint, samplePoint, result);
 return;
 }
 #endif
 #ifdef HAS_SPHERE_LIGHTS
-if (dP == SPHERE_LIGHT) {
-eM(light, shadingPoint, samplePoint, result);
+if (ec == SPHERE_LIGHT) {
+eY(light, shadingPoint, samplePoint, result);
 return;
 }
 #endif
 #ifdef HAS_SPOT_LIGHTS
-if (dP == SPOT_LIGHT) {
-jT(light, shadingPoint, samplePoint, result);
+if (ec == SPOT_LIGHT) {
+kx(light, shadingPoint, samplePoint, result);
 return;
 }
 #endif
 #ifdef HAS_DIRECTIONAL_LIGHTS
-if (dP == DIRECTIONAL_LIGHT) {
-gc(light, shadingPoint, result);
+if (ec == DIRECTIONAL_LIGHT) {
+gs(light, shadingPoint, result);
 }
 #endif
 }
 #endif
 
-void mH(in vec2 samplePoint, inout LightSampleRec result) {
+void nD(in vec2 samplePoint, inout LightSampleRec result) {
 vec2 uv;
-result.direction = oM(samplePoint, uv, result.pdf);
+result.direction = pI(samplePoint, uv, result.pdf);
 result.emission = textureLinear(envMap, uv).rgb;
 result.dist = INF;
 }
@@ -217,36 +217,36 @@ void sampleLight(
 in vec3 shadingPoint,
 in vec3 randomSampleValue,
 inout LightSampleRec result,
-bool sc
+bool tk
 ) {
 result.isDelta = false;
-float uc = randomSampleValue.z;
-bool kA = false;
+float vE = randomSampleValue.z;
+bool le = false;
 #ifdef USE_ENVMAP
-kA = uc < envLightSelectionPmf;
-if (kA) {
-mH(randomSampleValue.xy, result);
+le = vE < envLightSelectionPmf;
+if (le) {
+nD(randomSampleValue.xy, result);
 result.pdf *= envLightSelectionPmf;
 }
 #endif
 
 #ifdef NUM_LIGHTS
-if (!kA) {
-int lc = NUM_LIGHTS - 1;
+if (!le) {
+int lM = NUM_LIGHTS - 1;
 for (int index = 0; index < NUM_LIGHTS; index++) {
-if (uc < qx(index).selectionCdf) {
-lc = index;
+if (vE < rB(index).selectionCdf) {
+lM = index;
 break;
 }
 }
-Light qn = qx(lc);
-iQ(
-qn,
+Light rp = rB(lM);
+jg(
+rp,
 shadingPoint,
 randomSampleValue.xy,
 result
 );
-result.pdf *= qn.selectionPmf;
+result.pdf *= rp.selectionPmf;
 }
 #endif
 }