@meimu/mutracer 0.3.0 → 0.3.1

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

@@ -5,13 +5,13 @@ import { glsl } from '../../shader.js';
 export default glsl `
 uvec4 s0;
 
-void fi(vec2 p, int frame) {
+void fA(vec2 p, int frame) {
 
 s0 = uvec4(p, uint(frame), uint(p.x) + uint(p.y));
 }
 
 
-void xF(inout uvec4 v) {
+void zF(inout uvec4 v) {
 v = v * 1664525u + 1013904223u;
 v.x += v.y*v.w; v.y += v.z*v.x; v.z += v.x*v.y; v.w += v.y*v.z;
 v = v ^ (v>>16u);
@@ -19,7 +19,7 @@ v.x += v.y*v.w; v.y += v.z*v.x; v.z += v.x*v.y; v.w += v.y*v.z;
 }
 
 float rand() {
-xF(s0); return float(s0.x)/float(0xffffffffu);
+zF(s0); return float(s0.x)/float(0xffffffffu);
 }
 
 `;

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

@@ -10,13 +10,13 @@ export default createShaderMixin({
 
 ${sobol}
 
-void rA() {
-aI = uvec2(v_Texcoord / pixelSize);
+void sP() {
+aJ = uvec2(v_Texcoord / pixelSize);
 aC = uint(sampleCount);
-samplingBounce = 0u; ca = 0u;
+samplingBounce = 0u; hashedCounter = 0u;
 }
 
-vec2 te() {
+vec2 uH() {
 if (samplingPattern == 0 || samplingPattern == 1) {
 return (sample2D(CAMERA_PIXEL) - 0.5) * pixelSize;
 }

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

@@ -24,7 +24,7 @@ export function createRayTraceCoreGlsl(fragments = {}) {
         main: glsl `
 
 const vec3 luminance = vec3(0.2126, 0.7152, 0.0722);
-const int xO = 8;
+const int zL = 8;
 
 #define RAY_MAX_DISTANCE 9999.0
 
@@ -165,22 +165,24 @@ ray.tMax = RAY_MAX_DISTANCE;
 }
 
 
-ivec2 gM(int i, int jE) {
+ivec2 uO(int i, int ki) {
 ivec2 u;
-u.y = i >> jE; 
-u.x = i - (u.y << jE); 
+u.y = i >> ki; 
+u.x = i - (u.y << ki); 
 return u;
 }
 
-vec4 fetchData(sampler2D s, int i, int jE) {
-return texelFetch(s, gM(i, jE), 0);
+vec4 fetchData(sampler2D s, int i, int ki) {
+return texelFetch(s, uO(i, ki), 0);
 }
 
-ivec4 fetchData(highp isampler2D s, int i, int jE) {
-return texelFetch(s, gM(i, jE), 0);
+ivec4 fetchData(highp isampler2D s, int i, int ki) {
+return texelFetch(s, uO(i, ki), 0);
 }
 
 struct Path {
+
+bool scatteringMediumEntered;
 Ray ray;
 vec3 li;
 float alpha;
@@ -216,12 +218,12 @@ lightsTex,
 ivec2(firstTexel + 1, 0),
 0
 );
-vec4 oB = texelFetch(
+vec4 pG = texelFetch(
 lightsTex,
 ivec2(firstTexel + 2, 0),
 0
 );
-vec4 me = texelFetch(
+vec4 mW = texelFetch(
 lightsTex,
 ivec2(firstTexel + 3, 0),
 0
@@ -234,31 +236,31 @@ ivec2(firstTexel + 4, 0),
 return Light(
 positionAndPmf.xyz,
 emissionAndCdf.xyz,
-oB.xyz,
-me.xyz,
+pG.xyz,
+mW.xyz,
 shape.x,
 shape.y,
 shape.z,
-int(me.w),
-oB.w,
+int(mW.w),
+pG.w,
 positionAndPmf.w,
 emissionAndCdf.w,
 texelFetch(lightsTex, ivec2(firstTexel + 5, 0), 0).xyz
 );
 }
 
-float cF(int dV, int lK) {
-int im = dV + lK / 4;
+float cI(int ec, int mC) {
+int iR = ec + mC / 4;
 vec4 packed = texelFetch(
 iesProfileData,
-ivec2(im % iesProfileColumns, im / iesProfileColumns),
+ivec2(iR % iesProfileColumns, iR / iesProfileColumns),
 0
 );
-return packed[lK % 4];
+return packed[mC % 4];
 }
 
-float ld(int dV, vec2 uv) {
-if (dV < 0) return 1.0;
+float lW(int ec, vec2 uv) {
+if (ec < 0) return 1.0;
 vec2 pixel = fract(uv) * 128.0 - 0.5;
 ivec2 p0 = ivec2(floor(pixel));
 vec2 f = fract(pixel);
@@ -266,25 +268,25 @@ int xa = p0.x < 0 ? 127 : p0.x;
 int xb = p0.x >= 127 ? 0 : p0.x + 1;
 int ya = p0.y < 0 ? 127 : p0.y;
 int yb = p0.y >= 127 ? 0 : p0.y + 1;
-float a = cF(dV, ya * 128 + xa);
-float b = cF(dV, ya * 128 + xb);
-float c = cF(dV, yb * 128 + xa);
-float d = cF(dV, yb * 128 + xb);
+float a = cI(ec, ya * 128 + xa);
+float b = cI(ec, ya * 128 + xb);
+float c = cI(ec, yb * 128 + xa);
+float d = cI(ec, yb * 128 + xb);
 return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
 }
 
-float evaluateSpotEmissionMultiplier(Light light, vec3 dI) {
+float evaluateSpotEmissionMultiplier(Light light, vec3 dL) {
 vec3 axis = normalize(light.u);
-float ct = dot(axis, dI);
-float vw = light.v.y > light.v.x + 1e-6
-? smoothstep(light.v.x, light.v.y, ct)
-: step(light.v.x, ct);
-if (vw <= 0.0 || light.textureIndex < 0) return vw;
-vec3 vX = light.iesReference;
-vec3 xN = cross(axis, vX);
-float vertical = acos(clamp(ct, -1.0, 1.0));
-float horizontal = atan(dot(dI, xN), dot(dI, vX));
-return vw * ld(light.textureIndex, vec2(vertical / PI, horizontal / TWOPI + 0.5));
+float cv = dot(axis, dL);
+float xm = light.v.y > light.v.x + 1e-6
+? smoothstep(light.v.x, light.v.y, cv)
+: step(light.v.x, cv);
+if (xm <= 0.0 || light.textureIndex < 0) return xm;
+vec3 xT = light.iesReference;
+vec3 zK = cross(axis, xT);
+float vertical = acos(clamp(cv, -1.0, 1.0));
+float horizontal = atan(dot(dL, zK), dot(dL, xT));
+return xm * lW(light.textureIndex, vec2(vertical / PI, horizontal / TWOPI + 0.5));
 }
 `
     });

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,yBAAyB,CAAC;AAE9D,MAAM,UAAU,sBAAsB,CAAC,YAA8C,EAAE;IAAI,OAAO,iBAAiB,CAAC;QAClH,QAAQ,EAAE;YACR,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;YACtC,cAAc,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;YAC3C,iBAAiB,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;YAC3C,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;YACjC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;YAC9B,WAAW,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC;YAClC,oBAAoB,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;SACjD;QACD,OAAO,EAAE;YACP,QAAQ,EAAE,CAAC;YACX,KAAK,EAAE,aAAa;YACpB,cAAc,EAAE,qBAAqB;YACrC,UAAU,EAAE,mBAAmB;SAChC;QACD,IAAI,EAAE,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BA6DgB,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2G1B,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiGjD;KACA,CAAC,CAAC;AACH,CAAC;AACD,eAAe,sBAAsB,EAAE,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 function createRayTraceCoreGlsl(fragments: Readonly<Record<string, string>> = {}) { return 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;${fragments['core0'] ?? ''}\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;${fragments['core1'] ?? ''}\n};\n\nstruct LightSampleRec {\n  vec3 normal;\n  vec3 emission;\n  vec3 direction;\n  float dist;\n  float pdf;\n  bool isDelta;\n  int sourceType;\n  int sourceIndex;\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}\nexport default createRayTraceCoreGlsl();\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,MAAM,UAAU,sBAAsB,CAAC,YAA8C,EAAE;IAAI,OAAO,iBAAiB,CAAC;QAClH,QAAQ,EAAE;YACR,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;YACtC,cAAc,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;YAC3C,iBAAiB,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;YAC3C,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;YACjC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;YAC9B,WAAW,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC;YAClC,oBAAoB,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;SACjD;QACD,OAAO,EAAE;YACP,QAAQ,EAAE,CAAC;YACX,KAAK,EAAE,aAAa;YACpB,cAAc,EAAE,qBAAqB;YACrC,UAAU,EAAE,mBAAmB;SAChC;QACD,IAAI,EAAE,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BA6DgB,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6G1B,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiGjD;KACA,CAAC,CAAC;AACH,CAAC;AACD,eAAe,sBAAsB,EAAE,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 function createRayTraceCoreGlsl(fragments: Readonly<Record<string, string>> = {}) { return 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;${fragments['core0'] ?? ''}\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  // Retain deferred roulette after an SSS walk reaches its boundary.\n  bool scatteringMediumEntered;\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;${fragments['core1'] ?? ''}\n};\n\nstruct LightSampleRec {\n  vec3 normal;\n  vec3 emission;\n  vec3 direction;\n  float dist;\n  float pdf;\n  bool isDelta;\n  int sourceType;\n  int sourceIndex;\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}\nexport default createRayTraceCoreGlsl();\n"]}

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

@@ -2,14 +2,14 @@ import emissive from './emissiveLight.glsl.js';
 import { glsl } from '../../shader.js';
 export default glsl `
 #ifdef NUM_LIGHTS
-void eH(
+void eR(
 in Light light,
 in vec3 shadingPoint,
 in vec2 samplePoint,
 inout LightSampleRec result
 ) {
-vec3 oC = light.position - shadingPoint;
-float ao = length(oC);
+vec3 pH = light.position - shadingPoint;
+float ao = length(pH);
 if (light.radius <= 0.0) {
 if (ao <= 1e-6) {
 result.direction = vec3(0.0, 0.0, 1.0);
@@ -20,7 +20,7 @@ result.emission = vec3(0.0);
 result.isDelta = true;
 return;
 }
-result.direction = oC / ao;
+result.direction = pH / ao;
 result.normal = -result.direction;
 result.dist = ao;
 result.pdf = 1.0;
@@ -29,57 +29,53 @@ result.isDelta = true;
 return;
 }
 float radius = max(light.radius, 1e-6);
-#ifdef HAS_EMISSIVE_LIGHTS
-jb(shadingPoint,randomSampleValue,result);return;
-#endif
-result.sourceType=0;result.sourceIndex=-1;
 result.isDelta = false;
 vec3 direction;
 
 if (ao <= radius) {
 float z = 1.0 - 2.0 * samplePoint.x;
-float dr = sqrt(max(0.0, 1.0 - z * z));
+float dw = sqrt(max(0.0, 1.0 - z * z));
 float azimuth = TWOPI * samplePoint.y;
-direction = vec3(dr * cos(azimuth), dr * sin(azimuth), z);
+direction = vec3(dw * cos(azimuth), dw * sin(azimuth), z);
 result.pdf = INV4PI;
 }
 else {
-vec3 axis = oC / ao;
-float oz = min(
+vec3 axis = pH / ao;
+float pv = min(
 1.0,
 radius * radius / (ao * ao)
 );
-float vA = sqrt(max(0.0, 1.0 - oz));
+float xn = sqrt(max(0.0, 1.0 - pv));
 
 
-float mf = oz / (1.0 + vA);
-float ng = samplePoint.x * mf;
-float cosine = 1.0 - ng;
-float uC = sqrt(max(0.0, ng * (2.0 - ng)));
+float mX = pv / (1.0 + xn);
+float oe = samplePoint.x * mX;
+float cosine = 1.0 - oe;
+float wk = sqrt(max(0.0, oe * (2.0 - oe)));
 float azimuth = TWOPI * samplePoint.y;
 vec3 tangent;
 vec3 bitangent;
 sampling_orthonormal_basis(axis, tangent, bitangent);
 direction = axis * cosine
-+ tangent * (uC * cos(azimuth))
-+ bitangent * (uC * sin(azimuth));
-result.pdf = 1.0 / max(TWOPI * mf, 1e-8);
++ tangent * (wk * cos(azimuth))
++ bitangent * (wk * sin(azimuth));
+result.pdf = 1.0 / max(TWOPI * mX, 1e-8);
 }
 
-float ji = dot(direction, oC);
-float bj = ji * ji
-- dot(oC, oC) + radius * radius;
-float root = sqrt(max(0.0, bj));
-float cI = ji - root;
-float cw = ji + root;
-result.dist = cI > 1e-6 ? cI : cw;
+float jM = dot(direction, pH);
+float bk = jM * jM
+- dot(pH, pH) + radius * radius;
+float root = sqrt(max(0.0, bk));
+float cK = jM - root;
+float cB = jM + root;
+result.dist = cK > 1e-6 ? cK : cB;
 result.direction = direction;
 vec3 surfacePoint = shadingPoint + direction * result.dist;
 result.normal = normalize(surfacePoint - light.position);
 result.emission = light.emission;
 }
 
-void bC(
+void bD(
 in Light light,
 in vec3 surfacePoint,
 in vec3 lowerLeft,
@@ -89,17 +85,17 @@ inout LightSampleRec result
 if (light.textureIndex >= 0) {
 float width = length(light.u);
 float height = length(light.v);
-vec3 dU = surfacePoint - lowerLeft;
+vec3 ea = surfacePoint - lowerLeft;
 vec2 uv = vec2(
-dot(dU, light.u / width) / width,
-dot(dU, light.v / height) / height
+dot(ea, light.u / width) / width,
+dot(ea, light.v / height) / height
 );
 result.emission *= sampleMap(light.textureIndex, uv).rgb;
 }
 #endif
 }
 
-void jZ(
+void kF(
 in Light light,
 in vec3 shadingPoint,
 in vec2 samplePoint,
@@ -110,28 +106,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 gg = dot(normal, shadingPoint - light.position);
-vec3 surfacePoint = shadingPoint - normal * gg;
-vec3 dU = surfacePoint - lowerLeft;
+float gy = dot(normal, shadingPoint - light.position);
+vec3 surfacePoint = shadingPoint - normal * gy;
+vec3 ea = surfacePoint - lowerLeft;
 float width = length(light.u);
 float height = length(light.v);
 vec2 uv = vec2(
-dot(dU, light.u / width) / width,
-dot(dU, light.v / height) / height
+dot(ea, light.u / width) / width,
+dot(ea, light.v / height) / height
 );
-if (gg <= 0.0 || any(lessThan(uv, vec2(0.0)))
+if (gy <= 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 = gg;
+result.dist = gy;
 result.normal = normal;
 result.emission = light.emission;
 result.pdf = 1.0;
 result.isDelta = true;
-bC(light, surfacePoint, lowerLeft, result);
+bD(light, surfacePoint, lowerLeft, result);
 return;
 }
 
@@ -143,19 +139,19 @@ float bG = dot(offset, offset);
 result.dist = sqrt(bG);
 result.direction = offset / result.dist;
 result.normal = normal;
-float fY = dot(-result.direction, normal);
-float pp = cos(0.5 * PI * spread);
-if (fY <= 0.0 || fY < pp) {
+float gq = dot(-result.direction, normal);
+float qB = cos(0.5 * PI * spread);
+if (gq <= 0.0 || gq < qB) {
 result.emission = vec3(0.0);
 result.pdf = 0.0;
 return;
 }
 result.emission = light.emission;
-result.pdf = bG / max(light.area * fY, 1e-8);
-bC(light, surfacePoint, lowerLeft, result);
+result.pdf = bG / max(light.area * gq, 1e-8);
+bD(light, surfacePoint, lowerLeft, result);
 }
 
-void gc(
+void gs(
 in Light light,
 in vec3 shadingPoint,
 inout LightSampleRec result
@@ -168,13 +164,13 @@ result.pdf = 1.0;
 result.isDelta = true;
 }
 
-void ka(
+void kG(
 in Light light,
 in vec3 shadingPoint,
 in vec2 samplePoint,
 inout LightSampleRec result
 ) {
-eH(light, shadingPoint, samplePoint, result);
+eR(light, shadingPoint, samplePoint, result);
 vec3 surfacePoint = shadingPoint + result.direction * result.dist;
 result.emission *= evaluateSpotEmissionMultiplier(
 light,
@@ -188,36 +184,36 @@ in vec3 shadingPoint,
 in vec2 samplePoint,
 inout LightSampleRec result
 ) {
-int dO = int(light.type);
+int dU = int(light.type);
 #ifdef HAS_RECT_LIGHTS
-if (dO == RECT_LIGHT) {
-jZ(light, shadingPoint, samplePoint, result);
+if (dU == RECT_LIGHT) {
+kF(light, shadingPoint, samplePoint, result);
 return;
 }
 #endif
 #ifdef HAS_SPHERE_LIGHTS
-if (dO == SPHERE_LIGHT) {
-eH(light, shadingPoint, samplePoint, result);
+if (dU == SPHERE_LIGHT) {
+eR(light, shadingPoint, samplePoint, result);
 return;
 }
 #endif
 #ifdef HAS_SPOT_LIGHTS
-if (dO == SPOT_LIGHT) {
-ka(light, shadingPoint, samplePoint, result);
+if (dU == SPOT_LIGHT) {
+kG(light, shadingPoint, samplePoint, result);
 return;
 }
 #endif
 #ifdef HAS_DIRECTIONAL_LIGHTS
-if (dO == DIRECTIONAL_LIGHT) {
-gc(light, shadingPoint, result);
+if (dU == DIRECTIONAL_LIGHT) {
+gs(light, shadingPoint, result);
 }
 #endif
 }
 #endif
 
-void ig(in vec2 samplePoint, inout LightSampleRec result) {
+void iM(in vec2 samplePoint, inout LightSampleRec result) {
 vec2 uv;
-result.direction = pn(samplePoint, uv, result.pdf);
+result.direction = qx(samplePoint, uv, result.pdf);
 result.emission = textureLinear(envMap, uv).rgb;
 result.dist = INF;
 }
@@ -230,41 +226,41 @@ void sampleLight(
 in vec3 shadingPoint,
 in vec3 randomSampleValue,
 inout LightSampleRec result,
-bool tk
+bool uP
 ) {
 #ifdef HAS_EMISSIVE_LIGHTS
-jb(shadingPoint,randomSampleValue,result);return;
+pc(shadingPoint,randomSampleValue,result);return;
 #endif
 result.sourceType=0;result.sourceIndex=-1;
 result.isDelta = false;
-float vP = randomSampleValue.z;
-bool kN = false;
+float xJ = randomSampleValue.z;
+bool lG = false;
 #ifdef USE_ENVMAP
-kN = vP < envLightSelectionPmf;
-if (kN) {
-ig(randomSampleValue.xy, result);
+lG = xJ < envLightSelectionPmf;
+if (lG) {
+iM(randomSampleValue.xy, result);
 result.pdf *= envLightSelectionPmf;
 }
 #endif
 
 #ifdef NUM_LIGHTS
-if (!kN) {
-int jc = NUM_LIGHTS - 1;
+if (!lG) {
+int jG = NUM_LIGHTS - 1;
 for (int index = 0; index < NUM_LIGHTS; index++) {
-if (vP < fetchLight(index).selectionCdf) {
-jc = index;
+if (xJ < fetchLight(index).selectionCdf) {
+jG = index;
 break;
 }
 }
-result.sourceType=2;result.sourceIndex=jc;
-Light rh = fetchLight(jc);
+result.sourceType=2;result.sourceIndex=jG;
+Light sz = fetchLight(jG);
 sampleAnalyticLight(
-rh,
+sz,
 shadingPoint,
 randomSampleValue.xy,
 result
 );
-result.pdf *= rh.selectionPmf;
+result.pdf *= sz.selectionPmf;
 }
 #endif
 }

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

@@ -1 +1 @@
-{"version":3,"file":"sampleLight.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/sampleLight.glsl.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,yBAAyB,CAAC;AAC/C,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+NjB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CT,CAAC","sourcesContent":["import emissive from './emissiveLight.glsl.js';\nimport { glsl } from '../../shader.js';\n\nexport default glsl`\n#ifdef NUM_LIGHTS\nvoid light_sample_sphere(\n  in Light light,\n  in vec3 shadingPoint,\n  in vec2 samplePoint,\n  inout LightSampleRec result\n) {\n  vec3 toCenter = light.position - shadingPoint;\n  float centerDistance = length(toCenter);\n  if (light.radius <= 0.0) {\n    if (centerDistance <= 1e-6) {\n      result.direction = vec3(0.0, 0.0, 1.0);\n      result.normal = vec3(0.0, 0.0, -1.0);\n      result.dist = 0.0;\n      result.pdf = 1.0;\n      result.emission = vec3(0.0);\n      result.isDelta = true;\n      return;\n    }\n    result.direction = toCenter / centerDistance;\n    result.normal = -result.direction;\n    result.dist = centerDistance;\n    result.pdf = 1.0;\n    result.emission = light.emission / max(centerDistance * centerDistance, 1e-8);\n    result.isDelta = true;\n    return;\n  }\n  float radius = max(light.radius, 1e-6);\n#ifdef HAS_EMISSIVE_LIGHTS\n  sampleEmissiveSceneLight(shadingPoint,randomSampleValue,result);return;\n#endif\n  result.sourceType=0;result.sourceIndex=-1;\n  result.isDelta = false;\n  vec3 direction;\n\n  if (centerDistance <= radius) {\n    float z = 1.0 - 2.0 * samplePoint.x;\n    float radial = sqrt(max(0.0, 1.0 - z * z));\n    float azimuth = TWOPI * samplePoint.y;\n    direction = vec3(radial * cos(azimuth), radial * sin(azimuth), z);\n    result.pdf = INV4PI;\n  }\n  else {\n    vec3 axis = toCenter / centerDistance;\n    float sineLimitSquared = min(\n      1.0,\n      radius * radius / (centerDistance * centerDistance)\n    );\n    float cosineLimit = sqrt(max(0.0, 1.0 - sineLimitSquared));\n    // Keep the small solid angle and sampled sine without subtracting\n    // nearly equal floats; otherwise small emitters produce irradiance bands.\n    float oneMinusCosineLimit = sineLimitSquared / (1.0 + cosineLimit);\n    float oneMinusCosine = samplePoint.x * oneMinusCosineLimit;\n    float cosine = 1.0 - oneMinusCosine;\n    float sine = sqrt(max(0.0, oneMinusCosine * (2.0 - oneMinusCosine)));\n    float azimuth = TWOPI * samplePoint.y;\n    vec3 tangent;\n    vec3 bitangent;\n    sampling_orthonormal_basis(axis, tangent, bitangent);\n    direction = axis * cosine\n      + tangent * (sine * cos(azimuth))\n      + bitangent * (sine * sin(azimuth));\n    result.pdf = 1.0 / max(TWOPI * oneMinusCosineLimit, 1e-8);\n  }\n\n  float projectedCenter = dot(direction, toCenter);\n  float discriminant = projectedCenter * projectedCenter\n    - dot(toCenter, toCenter) + radius * radius;\n  float root = sqrt(max(0.0, discriminant));\n  float nearDistance = projectedCenter - root;\n  float farDistance = projectedCenter + root;\n  result.dist = nearDistance > 1e-6 ? nearDistance : farDistance;\n  result.direction = direction;\n  vec3 surfacePoint = shadingPoint + direction * result.dist;\n  result.normal = normalize(surfacePoint - light.position);\n  result.emission = light.emission;\n}\n\nvoid light_apply_rect_texture(\n  in Light light,\n  in vec3 surfacePoint,\n  in vec3 lowerLeft,\n  inout LightSampleRec result\n) {\n#ifdef NUM_MAPS\n  if (light.textureIndex >= 0) {\n    float width = length(light.u);\n    float height = length(light.v);\n    vec3 relative = surfacePoint - lowerLeft;\n    vec2 uv = vec2(\n      dot(relative, light.u / width) / width,\n      dot(relative, light.v / height) / height\n    );\n    result.emission *= sampleMap(light.textureIndex, uv).rgb;\n  }\n#endif\n}\n\nvoid light_sample_rect(\n  in Light light,\n  in vec3 shadingPoint,\n  in vec2 samplePoint,\n  inout LightSampleRec result\n) {\n  vec3 normal = normalize(cross(light.u, light.v));\n  vec3 lowerLeft = light.position - 0.5 * (light.u + light.v);\n  float spread = clamp(light.spread, 0.0, 1.0);\n\n  if (spread <= 0.001) {\n    float planeDistance = dot(normal, shadingPoint - light.position);\n    vec3 surfacePoint = shadingPoint - normal * planeDistance;\n    vec3 relative = surfacePoint - lowerLeft;\n    float width = length(light.u);\n    float height = length(light.v);\n    vec2 uv = vec2(\n      dot(relative, light.u / width) / width,\n      dot(relative, light.v / height) / height\n    );\n    if (planeDistance <= 0.0 || any(lessThan(uv, vec2(0.0)))\n      || any(greaterThan(uv, vec2(1.0)))) {\n      result.emission = vec3(0.0);\n      result.pdf = 0.0;\n      return;\n    }\n    result.direction = -normal;\n    result.dist = planeDistance;\n    result.normal = normal;\n    result.emission = light.emission;\n    result.pdf = 1.0;\n    result.isDelta = true;\n    light_apply_rect_texture(light, surfacePoint, lowerLeft, result);\n    return;\n  }\n\n  vec3 surfacePoint = lowerLeft\n    + light.u * samplePoint.x\n    + light.v * samplePoint.y;\n  vec3 offset = surfacePoint - shadingPoint;\n  float distanceSquared = dot(offset, offset);\n  result.dist = sqrt(distanceSquared);\n  result.direction = offset / result.dist;\n  result.normal = normal;\n  float emitterCosine = dot(-result.direction, normal);\n  float spreadCosine = cos(0.5 * PI * spread);\n  if (emitterCosine <= 0.0 || emitterCosine < spreadCosine) {\n    result.emission = vec3(0.0);\n    result.pdf = 0.0;\n    return;\n  }\n  result.emission = light.emission;\n  result.pdf = distanceSquared / max(light.area * emitterCosine, 1e-8);\n  light_apply_rect_texture(light, surfacePoint, lowerLeft, result);\n}\n\nvoid light_sample_directional(\n  in Light light,\n  in vec3 shadingPoint,\n  inout LightSampleRec result\n) {\n  result.direction = normalize(-light.u);\n  result.normal = -result.direction;\n  result.emission = light.emission;\n  result.dist = INF;\n  result.pdf = 1.0;\n  result.isDelta = true;\n}\n\nvoid light_sample_spot(\n  in Light light,\n  in vec3 shadingPoint,\n  in vec2 samplePoint,\n  inout LightSampleRec result\n) {\n  light_sample_sphere(light, shadingPoint, samplePoint, result);\n  vec3 surfacePoint = shadingPoint + result.direction * result.dist;\n  result.emission *= evaluateSpotEmissionMultiplier(\n    light,\n    normalize(shadingPoint - surfacePoint)\n  );\n}\n\nvoid sampleAnalyticLight(\n  in Light light,\n  in vec3 shadingPoint,\n  in vec2 samplePoint,\n  inout LightSampleRec result\n) {\n  int lightType = int(light.type);\n#ifdef HAS_RECT_LIGHTS\n  if (lightType == RECT_LIGHT) {\n    light_sample_rect(light, shadingPoint, samplePoint, result);\n    return;\n  }\n#endif\n#ifdef HAS_SPHERE_LIGHTS\n  if (lightType == SPHERE_LIGHT) {\n    light_sample_sphere(light, shadingPoint, samplePoint, result);\n    return;\n  }\n#endif\n#ifdef HAS_SPOT_LIGHTS\n  if (lightType == SPOT_LIGHT) {\n    light_sample_spot(light, shadingPoint, samplePoint, result);\n    return;\n  }\n#endif\n#ifdef HAS_DIRECTIONAL_LIGHTS\n  if (lightType == DIRECTIONAL_LIGHT) {\n    light_sample_directional(light, shadingPoint, result);\n  }\n#endif\n}\n#endif\n\nvoid sampleEnvLight(in vec2 samplePoint, inout LightSampleRec result) {\n  vec2 uv;\n  result.direction = sampleEnvmap(samplePoint, uv, result.pdf);\n  result.emission = textureLinear(envMap, uv).rgb;\n  result.dist = INF;\n}\n\n#ifdef HAS_EMISSIVE_LIGHTS\n${emissive}\n#endif\n\nvoid sampleLight(\n  in vec3 shadingPoint,\n  in vec3 randomSampleValue,\n  inout LightSampleRec result,\n  bool distByIntensity\n) {\n#ifdef HAS_EMISSIVE_LIGHTS\n  sampleEmissiveSceneLight(shadingPoint,randomSampleValue,result);return;\n#endif\n  result.sourceType=0;result.sourceIndex=-1;\n  result.isDelta = false;\n  float selector = randomSampleValue.z;\n  bool choseEnvironment = false;\n#ifdef USE_ENVMAP\n  choseEnvironment = selector < envLightSelectionPmf;\n  if (choseEnvironment) {\n    sampleEnvLight(randomSampleValue.xy, result);\n    result.pdf *= envLightSelectionPmf;\n  }\n#endif\n\n#ifdef NUM_LIGHTS\n  if (!choseEnvironment) {\n    int selectedIndex = NUM_LIGHTS - 1;\n    for (int index = 0; index < NUM_LIGHTS; index++) {\n      if (selector < fetchLight(index).selectionCdf) {\n        selectedIndex = index;\n        break;\n      }\n    }\n    result.sourceType=2;result.sourceIndex=selectedIndex;\n    Light selectedLight = fetchLight(selectedIndex);\n    sampleAnalyticLight(\n      selectedLight,\n      shadingPoint,\n      randomSampleValue.xy,\n      result\n    );\n    result.pdf *= selectedLight.selectionPmf;\n  }\n#endif\n}\n`;\n"]}
+{"version":3,"file":"sampleLight.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/sampleLight.glsl.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,yBAAyB,CAAC;AAC/C,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2NjB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CT,CAAC","sourcesContent":["import emissive from './emissiveLight.glsl.js';\nimport { glsl } from '../../shader.js';\n\nexport default glsl`\n#ifdef NUM_LIGHTS\nvoid light_sample_sphere(\n  in Light light,\n  in vec3 shadingPoint,\n  in vec2 samplePoint,\n  inout LightSampleRec result\n) {\n  vec3 toCenter = light.position - shadingPoint;\n  float centerDistance = length(toCenter);\n  if (light.radius <= 0.0) {\n    if (centerDistance <= 1e-6) {\n      result.direction = vec3(0.0, 0.0, 1.0);\n      result.normal = vec3(0.0, 0.0, -1.0);\n      result.dist = 0.0;\n      result.pdf = 1.0;\n      result.emission = vec3(0.0);\n      result.isDelta = true;\n      return;\n    }\n    result.direction = toCenter / centerDistance;\n    result.normal = -result.direction;\n    result.dist = centerDistance;\n    result.pdf = 1.0;\n    result.emission = light.emission / max(centerDistance * centerDistance, 1e-8);\n    result.isDelta = true;\n    return;\n  }\n  float radius = max(light.radius, 1e-6);\n  result.isDelta = false;\n  vec3 direction;\n\n  if (centerDistance <= radius) {\n    float z = 1.0 - 2.0 * samplePoint.x;\n    float radial = sqrt(max(0.0, 1.0 - z * z));\n    float azimuth = TWOPI * samplePoint.y;\n    direction = vec3(radial * cos(azimuth), radial * sin(azimuth), z);\n    result.pdf = INV4PI;\n  }\n  else {\n    vec3 axis = toCenter / centerDistance;\n    float sineLimitSquared = min(\n      1.0,\n      radius * radius / (centerDistance * centerDistance)\n    );\n    float cosineLimit = sqrt(max(0.0, 1.0 - sineLimitSquared));\n    // Keep the small solid angle and sampled sine without subtracting\n    // nearly equal floats; otherwise small emitters produce irradiance bands.\n    float oneMinusCosineLimit = sineLimitSquared / (1.0 + cosineLimit);\n    float oneMinusCosine = samplePoint.x * oneMinusCosineLimit;\n    float cosine = 1.0 - oneMinusCosine;\n    float sine = sqrt(max(0.0, oneMinusCosine * (2.0 - oneMinusCosine)));\n    float azimuth = TWOPI * samplePoint.y;\n    vec3 tangent;\n    vec3 bitangent;\n    sampling_orthonormal_basis(axis, tangent, bitangent);\n    direction = axis * cosine\n      + tangent * (sine * cos(azimuth))\n      + bitangent * (sine * sin(azimuth));\n    result.pdf = 1.0 / max(TWOPI * oneMinusCosineLimit, 1e-8);\n  }\n\n  float projectedCenter = dot(direction, toCenter);\n  float discriminant = projectedCenter * projectedCenter\n    - dot(toCenter, toCenter) + radius * radius;\n  float root = sqrt(max(0.0, discriminant));\n  float nearDistance = projectedCenter - root;\n  float farDistance = projectedCenter + root;\n  result.dist = nearDistance > 1e-6 ? nearDistance : farDistance;\n  result.direction = direction;\n  vec3 surfacePoint = shadingPoint + direction * result.dist;\n  result.normal = normalize(surfacePoint - light.position);\n  result.emission = light.emission;\n}\n\nvoid light_apply_rect_texture(\n  in Light light,\n  in vec3 surfacePoint,\n  in vec3 lowerLeft,\n  inout LightSampleRec result\n) {\n#ifdef NUM_MAPS\n  if (light.textureIndex >= 0) {\n    float width = length(light.u);\n    float height = length(light.v);\n    vec3 relative = surfacePoint - lowerLeft;\n    vec2 uv = vec2(\n      dot(relative, light.u / width) / width,\n      dot(relative, light.v / height) / height\n    );\n    result.emission *= sampleMap(light.textureIndex, uv).rgb;\n  }\n#endif\n}\n\nvoid light_sample_rect(\n  in Light light,\n  in vec3 shadingPoint,\n  in vec2 samplePoint,\n  inout LightSampleRec result\n) {\n  vec3 normal = normalize(cross(light.u, light.v));\n  vec3 lowerLeft = light.position - 0.5 * (light.u + light.v);\n  float spread = clamp(light.spread, 0.0, 1.0);\n\n  if (spread <= 0.001) {\n    float planeDistance = dot(normal, shadingPoint - light.position);\n    vec3 surfacePoint = shadingPoint - normal * planeDistance;\n    vec3 relative = surfacePoint - lowerLeft;\n    float width = length(light.u);\n    float height = length(light.v);\n    vec2 uv = vec2(\n      dot(relative, light.u / width) / width,\n      dot(relative, light.v / height) / height\n    );\n    if (planeDistance <= 0.0 || any(lessThan(uv, vec2(0.0)))\n      || any(greaterThan(uv, vec2(1.0)))) {\n      result.emission = vec3(0.0);\n      result.pdf = 0.0;\n      return;\n    }\n    result.direction = -normal;\n    result.dist = planeDistance;\n    result.normal = normal;\n    result.emission = light.emission;\n    result.pdf = 1.0;\n    result.isDelta = true;\n    light_apply_rect_texture(light, surfacePoint, lowerLeft, result);\n    return;\n  }\n\n  vec3 surfacePoint = lowerLeft\n    + light.u * samplePoint.x\n    + light.v * samplePoint.y;\n  vec3 offset = surfacePoint - shadingPoint;\n  float distanceSquared = dot(offset, offset);\n  result.dist = sqrt(distanceSquared);\n  result.direction = offset / result.dist;\n  result.normal = normal;\n  float emitterCosine = dot(-result.direction, normal);\n  float spreadCosine = cos(0.5 * PI * spread);\n  if (emitterCosine <= 0.0 || emitterCosine < spreadCosine) {\n    result.emission = vec3(0.0);\n    result.pdf = 0.0;\n    return;\n  }\n  result.emission = light.emission;\n  result.pdf = distanceSquared / max(light.area * emitterCosine, 1e-8);\n  light_apply_rect_texture(light, surfacePoint, lowerLeft, result);\n}\n\nvoid light_sample_directional(\n  in Light light,\n  in vec3 shadingPoint,\n  inout LightSampleRec result\n) {\n  result.direction = normalize(-light.u);\n  result.normal = -result.direction;\n  result.emission = light.emission;\n  result.dist = INF;\n  result.pdf = 1.0;\n  result.isDelta = true;\n}\n\nvoid light_sample_spot(\n  in Light light,\n  in vec3 shadingPoint,\n  in vec2 samplePoint,\n  inout LightSampleRec result\n) {\n  light_sample_sphere(light, shadingPoint, samplePoint, result);\n  vec3 surfacePoint = shadingPoint + result.direction * result.dist;\n  result.emission *= evaluateSpotEmissionMultiplier(\n    light,\n    normalize(shadingPoint - surfacePoint)\n  );\n}\n\nvoid sampleAnalyticLight(\n  in Light light,\n  in vec3 shadingPoint,\n  in vec2 samplePoint,\n  inout LightSampleRec result\n) {\n  int lightType = int(light.type);\n#ifdef HAS_RECT_LIGHTS\n  if (lightType == RECT_LIGHT) {\n    light_sample_rect(light, shadingPoint, samplePoint, result);\n    return;\n  }\n#endif\n#ifdef HAS_SPHERE_LIGHTS\n  if (lightType == SPHERE_LIGHT) {\n    light_sample_sphere(light, shadingPoint, samplePoint, result);\n    return;\n  }\n#endif\n#ifdef HAS_SPOT_LIGHTS\n  if (lightType == SPOT_LIGHT) {\n    light_sample_spot(light, shadingPoint, samplePoint, result);\n    return;\n  }\n#endif\n#ifdef HAS_DIRECTIONAL_LIGHTS\n  if (lightType == DIRECTIONAL_LIGHT) {\n    light_sample_directional(light, shadingPoint, result);\n  }\n#endif\n}\n#endif\n\nvoid sampleEnvLight(in vec2 samplePoint, inout LightSampleRec result) {\n  vec2 uv;\n  result.direction = sampleEnvmap(samplePoint, uv, result.pdf);\n  result.emission = textureLinear(envMap, uv).rgb;\n  result.dist = INF;\n}\n\n#ifdef HAS_EMISSIVE_LIGHTS\n${emissive}\n#endif\n\nvoid sampleLight(\n  in vec3 shadingPoint,\n  in vec3 randomSampleValue,\n  inout LightSampleRec result,\n  bool distByIntensity\n) {\n#ifdef HAS_EMISSIVE_LIGHTS\n  sampleEmissiveSceneLight(shadingPoint,randomSampleValue,result);return;\n#endif\n  result.sourceType=0;result.sourceIndex=-1;\n  result.isDelta = false;\n  float selector = randomSampleValue.z;\n  bool choseEnvironment = false;\n#ifdef USE_ENVMAP\n  choseEnvironment = selector < envLightSelectionPmf;\n  if (choseEnvironment) {\n    sampleEnvLight(randomSampleValue.xy, result);\n    result.pdf *= envLightSelectionPmf;\n  }\n#endif\n\n#ifdef NUM_LIGHTS\n  if (!choseEnvironment) {\n    int selectedIndex = NUM_LIGHTS - 1;\n    for (int index = 0; index < NUM_LIGHTS; index++) {\n      if (selector < fetchLight(index).selectionCdf) {\n        selectedIndex = index;\n        break;\n      }\n    }\n    result.sourceType=2;result.sourceIndex=selectedIndex;\n    Light selectedLight = fetchLight(selectedIndex);\n    sampleAnalyticLight(\n      selectedLight,\n      shadingPoint,\n      randomSampleValue.xy,\n      result\n    );\n    result.pdf *= selectedLight.selectionPmf;\n  }\n#endif\n}\n`;\n"]}

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

@@ -1,3 +1,3 @@
-export declare function createSampleMaterialGlsl(fragments?: Readonly<Record<string, string>>): string;
+export declare function createSampleMaterialGlsl(fragments?: Readonly<Record<string, string>>, channelIndependentLight?: boolean): string;
 declare const _default: string;
 export default _default;