@meimu/mutracer 0.1.2 → 0.1.3

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

@@ -5,13 +5,13 @@ import { glsl } from '../../shader.js';
 export default glsl `
 uvec4 s0;
 
-void jY(vec2 p, int frame) {
+void ka(vec2 p, int frame) {
 
 s0 = uvec4(p, uint(frame), uint(p.x) + uint(p.y));
 }
 
 
-void vj(inout uvec4 v) {
+void vo(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() {
-vj(s0); return float(s0.x)/float(0xffffffffu);
+vo(s0); return float(s0.x)/float(0xffffffffu);
 }
 
 `;

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

@@ -10,13 +10,13 @@ export default createShaderMixin({
 
 ${sobol}
 
-void se() {
+void sk() {
 bc = uvec2(v_Texcoord / pixelSize);
 bd = uint(sampleCount);
-cE = 0u; em = 0u;
+cF = 0u; em = 0u;
 }
 
-vec2 rN() {
+vec2 rS() {
 if (samplingPattern == 0 || samplingPattern == 1) {
 return (fk(CAMERA_PIXEL) - 0.5) * pixelSize;
 }

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

@@ -23,7 +23,7 @@ export default createShaderMixin({
     main: glsl `
 
 const vec3 luminance = vec3(0.2126, 0.7152, 0.0722);
-const int vp = 8;
+const int vw = 8;
 
 #define RAY_MAX_DISTANCE 9999.0
 
@@ -163,19 +163,19 @@ ray.tMax = RAY_MAX_DISTANCE;
 }
 
 
-ivec2 gK(int i, int jq) {
+ivec2 gM(int i, int jt) {
 ivec2 u;
-u.y = i >> jq; 
-u.x = i - (u.y << jq); 
+u.y = i >> jt; 
+u.x = i - (u.y << jt); 
 return u;
 }
 
-vec4 kw(sampler2D s, int i, int jq) {
-return texelFetch(s, gK(i, jq), 0);
+vec4 ky(sampler2D s, int i, int jt) {
+return texelFetch(s, gM(i, jt), 0);
 }
 
-ivec4 kw(highp isampler2D s, int i, int jq) {
-return texelFetch(s, gK(i, jq), 0);
+ivec4 ky(highp isampler2D s, int i, int jt) {
+return texelFetch(s, gM(i, jt), 0);
 }
 
 struct Path {
@@ -200,24 +200,24 @@ bool isDelta;
 };
 
 
-Light ql(int i) {
+Light qp(int i) {
 int firstTexel = i * 6;
-vec4 ps = texelFetch(
+vec4 pG = texelFetch(
 lightsTex,
 ivec2(firstTexel, 0),
 0
 );
-vec4 pb = texelFetch(
+vec4 pf = texelFetch(
 lightsTex,
 ivec2(firstTexel + 1, 0),
 0
 );
-vec4 nC = texelFetch(
+vec4 nF = texelFetch(
 lightsTex,
 ivec2(firstTexel + 2, 0),
 0
 );
-vec4 lA = texelFetch(
+vec4 lD = texelFetch(
 lightsTex,
 ivec2(firstTexel + 3, 0),
 0
@@ -228,32 +228,32 @@ ivec2(firstTexel + 4, 0),
 0
 );
 return Light(
-ps.xyz,
-pb.xyz,
-nC.xyz,
-lA.xyz,
+pG.xyz,
+pf.xyz,
+nF.xyz,
+lD.xyz,
 shape.x,
 shape.y,
 shape.z,
-int(lA.w),
-nC.w,
-ps.w,
-pb.w,
+int(lD.w),
+nF.w,
+pG.w,
+pf.w,
 texelFetch(lightsTex, ivec2(firstTexel + 5, 0), 0).xyz
 );
 }
 
-float cL(int dV, int le) {
-int ij = dV + le / 4;
+float cL(int dV, int lh) {
+int ih = dV + lh / 4;
 vec4 packed = texelFetch(
 iesProfileData,
-ivec2(ij % iesProfileColumns, ij / iesProfileColumns),
+ivec2(ih % iesProfileColumns, ih / iesProfileColumns),
 0
 );
-return packed[le % 4];
+return packed[lh % 4];
 }
 
-float kF(int dV, vec2 uv) {
+float kI(int dV, vec2 uv) {
 if (dV < 0) return 1.0;
 vec2 fM = fract(uv) * 128.0 - 0.5;
 ivec2 p0 = ivec2(floor(fM));
@@ -272,15 +272,15 @@ return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
 float bL(Light light, vec3 dJ) {
 vec3 axis = normalize(light.u);
 float cc = dot(axis, dJ);
-float tD = light.v.y > 1e-6
+float tI = light.v.y > 1e-6
 ? smoothstep(light.v.x, light.v.x + light.v.y, cc)
 : step(light.v.x, cc);
-if (tD <= 0.0 || light.textureIndex < 0) return tD;
-vec3 tX = light.iesReference;
-vec3 vo = cross(axis, tX);
+if (tI <= 0.0 || light.textureIndex < 0) return tI;
+vec3 uc = light.iesReference;
+vec3 vu = cross(axis, uc);
 float vertical = acos(clamp(cc, -1.0, 1.0));
-float horizontal = atan(dot(dJ, vo), dot(dJ, tX));
-return tD * kF(light.textureIndex, vec2(vertical / PI, horizontal / TWOPI + 0.5));
+float horizontal = atan(dot(dJ, vu), dot(dJ, uc));
+return tI * kI(light.textureIndex, vec2(vertical / PI, horizontal / TWOPI + 0.5));
 }
 `
 });

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

@@ -7,8 +7,8 @@ in vec3 shadingPoint,
 in vec2 samplePoint,
 inout LightSampleRec result
 ) {
-vec3 nE = light.position - shadingPoint;
-float aj = length(nE);
+vec3 nH = light.position - shadingPoint;
+float aj = length(nH);
 if (light.radius <= 0.0) {
 if (aj <= 1e-6) {
 result.direction = vec3(0.0, 0.0, 1.0);
@@ -19,7 +19,7 @@ result.emission = vec3(0.0);
 result.isDelta = true;
 return;
 }
-result.direction = nE / aj;
+result.direction = nH / aj;
 result.normal = -result.direction;
 result.dist = aj;
 result.pdf = 1.0;
@@ -39,31 +39,31 @@ direction = vec3(fi * cos(br), fi * sin(br), z);
 result.pdf = INV4PI;
 }
 else {
-vec3 axis = nE / aj;
-float rG = min(
+vec3 axis = nH / aj;
+float rL = min(
 1.0,
 radius * radius / (aj * aj)
 );
-float rJ = sqrt(max(0.0, 1.0 - rG));
-float au = mix(1.0, rJ, samplePoint.x);
-float tR = sqrt(max(0.0, 1.0 - au * au));
+float rO = sqrt(max(0.0, 1.0 - rL));
+float au = mix(1.0, rO, samplePoint.x);
+float tW = sqrt(max(0.0, 1.0 - au * au));
 float br = TWOPI * samplePoint.y;
 vec3 tangent;
 vec3 bitangent;
-aK(axis, tangent, bitangent);
+aL(axis, tangent, bitangent);
 direction = axis * au
-+ tangent * (tR * cos(br))
-+ bitangent * (tR * sin(br));
-result.pdf = 1.0 / max(TWOPI * (1.0 - rJ), 1e-8);
++ tangent * (tW * cos(br))
++ bitangent * (tW * sin(br));
+result.pdf = 1.0 / max(TWOPI * (1.0 - rO), 1e-8);
 }
 
-float iZ = dot(direction, nE);
-float ej = iZ * iZ
-- dot(nE, nE) + radius * radius;
-float wu = sqrt(max(0.0, ej));
-float cN = iZ - wu;
-float cB = iZ + wu;
-result.dist = cN > 1e-6 ? cN : cB;
+float jb = dot(direction, nH);
+float ej = jb * jb
+- dot(nH, nH) + radius * radius;
+float wB = sqrt(max(0.0, ej));
+float cN = jb - wB;
+float cC = jb + wB;
+result.dist = cN > 1e-6 ? cN : cC;
 result.direction = direction;
 vec3 surfacePoint = shadingPoint + direction * result.dist;
 result.normal = normalize(surfacePoint - light.position);
@@ -80,17 +80,17 @@ inout LightSampleRec result
 if (light.textureIndex >= 0) {
 float width = length(light.u);
 float height = length(light.v);
-vec3 hY = surfacePoint - lowerLeft;
+vec3 hX = surfacePoint - lowerLeft;
 vec2 uv = vec2(
-dot(hY, light.u / width) / width,
-dot(hY, light.v / height) / height
+dot(hX, light.u / width) / width,
+dot(hX, light.v / height) / height
 );
 result.emission *= sampleMap(light.textureIndex, uv).rgb;
 }
 #endif
 }
 
-void jJ(
+void jL(
 in Light light,
 in vec3 shadingPoint,
 in vec2 samplePoint,
@@ -101,23 +101,23 @@ vec3 lowerLeft = light.position - 0.5 * (light.u + light.v);
 float spread = clamp(light.spread, 0.0, 1.0);
 
 if (spread <= 0.001) {
-float ga = dot(normal, shadingPoint - light.position);
-vec3 surfacePoint = shadingPoint - normal * ga;
-vec3 hY = surfacePoint - lowerLeft;
+float gb = dot(normal, shadingPoint - light.position);
+vec3 surfacePoint = shadingPoint - normal * gb;
+vec3 hX = surfacePoint - lowerLeft;
 float width = length(light.u);
 float height = length(light.v);
 vec2 uv = vec2(
-dot(hY, light.u / width) / width,
-dot(hY, light.v / height) / height
+dot(hX, light.u / width) / width,
+dot(hX, light.v / height) / height
 );
-if (ga <= 0.0 || any(lessThan(uv, vec2(0.0)))
+if (gb <= 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 = ga;
+result.dist = gb;
 result.normal = normal;
 result.emission = light.emission;
 result.pdf = 1.0;
@@ -135,8 +135,8 @@ result.dist = sqrt(hl);
 result.direction = offset / result.dist;
 result.normal = normal;
 float fV = dot(-result.direction, normal);
-float oC = cos(0.5 * PI * spread);
-if (fV <= 0.0 || fV < oC) {
+float oF = cos(0.5 * PI * spread);
+if (fV <= 0.0 || fV < oF) {
 result.emission = vec3(0.0);
 result.pdf = 0.0;
 return;
@@ -146,7 +146,7 @@ result.pdf = hl / max(light.area * fV, 1e-8);
 cZ(light, surfacePoint, lowerLeft, result);
 }
 
-void fX(
+void fY(
 in Light light,
 in vec3 shadingPoint,
 inout LightSampleRec result
@@ -159,7 +159,7 @@ result.pdf = 1.0;
 result.isDelta = true;
 }
 
-void jK(
+void jM(
 in Light light,
 in vec3 shadingPoint,
 in vec2 samplePoint,
@@ -173,7 +173,7 @@ normalize(shadingPoint - surfacePoint)
 );
 }
 
-void iK(
+void iL(
 in Light light,
 in vec3 shadingPoint,
 in vec2 samplePoint,
@@ -182,7 +182,7 @@ inout LightSampleRec result
 int dO = int(light.type);
 #ifdef HAS_RECT_LIGHTS
 if (dO == RECT_LIGHT) {
-jJ(light, shadingPoint, samplePoint, result);
+jL(light, shadingPoint, samplePoint, result);
 return;
 }
 #endif
@@ -194,21 +194,21 @@ return;
 #endif
 #ifdef HAS_SPOT_LIGHTS
 if (dO == SPOT_LIGHT) {
-jK(light, shadingPoint, samplePoint, result);
+jM(light, shadingPoint, samplePoint, result);
 return;
 }
 #endif
 #ifdef HAS_DIRECTIONAL_LIGHTS
 if (dO == DIRECTIONAL_LIGHT) {
-fX(light, shadingPoint, result);
+fY(light, shadingPoint, result);
 }
 #endif
 }
 #endif
 
-void mu(in vec2 samplePoint, inout LightSampleRec result) {
+void mx(in vec2 samplePoint, inout LightSampleRec result) {
 vec2 uv;
-result.direction = oA(samplePoint, uv, result.pdf);
+result.direction = oD(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 rP
+bool rU
 ) {
 result.isDelta = false;
-float tQ = randomSampleValue.z;
-bool ko = false;
+float tV = randomSampleValue.z;
+bool kq = false;
 #ifdef USE_ENVMAP
-ko = tQ < envLightSelectionPmf;
-if (ko) {
-mu(randomSampleValue.xy, result);
+kq = tV < envLightSelectionPmf;
+if (kq) {
+mx(randomSampleValue.xy, result);
 result.pdf *= envLightSelectionPmf;
 }
 #endif
 
 #ifdef NUM_LIGHTS
-if (!ko) {
-int kQ = NUM_LIGHTS - 1;
+if (!kq) {
+int kT = NUM_LIGHTS - 1;
 for (int index = 0; index < NUM_LIGHTS; index++) {
-if (tQ < ql(index).selectionCdf) {
-kQ = index;
+if (tV < qp(index).selectionCdf) {
+kT = index;
 break;
 }
 }
-Light qb = ql(kQ);
-iK(
-qb,
+Light qf = qp(kT);
+iL(
+qf,
 shadingPoint,
 randomSampleValue.xy,
 result
 );
-result.pdf *= qb.selectionPmf;
+result.pdf *= qf.selectionPmf;
 }
 #endif
 }