@meimu/mutracer 0.1.2 → 0.1.3

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

@@ -8,14 +8,14 @@ import { materialAlphaModeConstants } from '../../../scene/OpenPBRMaterial.js';
  */
 export function createIntersectionAlphaWgsl(hasAnisotropyDirections = true) {
     return /* wgsl */ `
-fn nl(
-ph: i32,
+fn nr(
+pl: i32,
 index: vec3i,
 aB: vec3f,
 eU: vec3f,
 eC: vec3f
 ) -> bool {
-var materialIndex = ph;
+var materialIndex = pl;
 let m0 = vec3i(attrBuffers[index.x * ATTR_STRIDE + MATERIALINDEX_OFF]${hasAnisotropyDirections ? '.xyz' : ''});
 let m1 = vec3i(attrBuffers[index.y * ATTR_STRIDE + MATERIALINDEX_OFF]${hasAnisotropyDirections ? '.xyz' : ''});
 let m2 = vec3i(attrBuffers[index.z * ATTR_STRIDE + MATERIALINDEX_OFF]${hasAnisotropyDirections ? '.xyz' : ''});
@@ -37,7 +37,7 @@ let uv2 = attrBuffers[index.z * ATTR_STRIDE + UV_OFF].xy;
 var uv = aB.x * uv0 +
 aB.y * uv1 + aB.z * uv2;
 if (uvProjection > 0) {
-uv = gz(uvProjection, eU, eC);
+uv = gC(uvProjection, eU, eC);
 }
 uv *= ma.uvScale;
 if (uvProjection == ${uvProjectionConstants.triplanar}) {
@@ -57,7 +57,7 @@ let uv2 = attrBuffers[index.z * ATTR_STRIDE + UV_OFF].xy;
 var uv = aB.x * uv0 +
 aB.y * uv1 + aB.z * uv2;
 if (uvProjection > 0) {
-uv = gz(uvProjection, eU, eC);
+uv = gC(uvProjection, eU, eC);
 }
 uv *= ma.uvScale;
 if (uvProjection == ${uvProjectionConstants.triplanar}) {

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

@@ -29,43 +29,43 @@ return vec2f(pow((a*a + u*u) * 0.5, 0.25), clamp(1.0 - u/a, 0.0, 1.0));
 }
 ` : /* wgsl */ ``}
 
-fn oy(c: vec3f) -> vec3f {
+fn oB(c: vec3f) -> vec3f {
 return mix(pow(c * 0.9478672986 + 0.0521327014, vec3f(2.4)), c * 0.0773993808, vec3f(c < vec3f(0.04045)));
 }
 
 fn decodeMapColor(idx: i32, c: vec3f) -> vec3f {
 if (mapInfo[idx + NUM_MAPS * 2].y > 0.5) { return c; }
-return oy(c);
+return oB(c);
 }
 
 fn ae(val: i32) -> vec2f {
 return vec2f(f32(val >> 8), f32(val & 0xff) / 255.0);
 }
 
-fn nX(idx: i32) -> vec2f {
+fn oa(idx: i32) -> vec2f {
 return mapInfo[idx].xy;
 }
 
-fn pf(idx: i32) -> i32 {
+fn pj(idx: i32) -> i32 {
 return i32(floor(mapInfo[idx].z));
 }
 
-fn nW(idx: i32) -> vec2f {
+fn nZ(idx: i32) -> vec2f {
 return vec2f(fract(mapInfo[idx].z), mapInfo[idx].w);
 }
 
-fn sb(idx: i32, uv: vec2f) -> vec2f {
+fn sg(idx: i32, uv: vec2f) -> vec2f {
 let transform = mapInfo[idx + NUM_MAPS];
-let qv = fract(uv * transform.xy + transform.zw);
-let je = 1.0 / vec2f(textureDimensions(map).xy);
-let dZ = nW(idx);
-let ke = nX(idx) + je;
-let oB = dZ - 0.5 * je;
-let lo = dZ + ke - je;
+let qz = fract(uv * transform.xy + transform.zw);
+let jg = 1.0 / vec2f(textureDimensions(map).xy);
+let dZ = nZ(idx);
+let kg = oa(idx) + jg;
+let oE = dZ - 0.5 * jg;
+let lr = dZ + kg - jg;
 return clamp(
-oB + qv * ke,
+oE + qz * kg,
 dZ,
-lo
+lr
 );
 }
 
@@ -74,11 +74,11 @@ return select(uv, uv1, mapInfo[idx + NUM_MAPS * 2].x > 0.5);
 }
 
 fn sampleMap(idx: i32, uv: vec2f) -> vec4f {
-return textureSampleLevel(map, mapSampler, sb(idx, uv), pf(idx), 0.0);
+return textureSampleLevel(map, mapSampler, sg(idx, uv), pj(idx), 0.0);
 }
 
 
-fn lB(materialIndex: i32, uv: vec2f, uv1: vec2f) -> vec3f {
+fn lE(materialIndex: i32, uv: vec2f, uv1: vec2f) -> vec3f {
 let matData = materialsBuffer[materialIndex];
 var emission = matData.emission;
 if (USE_EMISSIVE_MAPS) {
@@ -102,16 +102,16 @@ return emission;
 }
 
 
-fn aJ(roughness: f32, anisotropy: f32) -> vec2f {
+fn aK(roughness: f32, anisotropy: f32) -> vec2f {
 let alpha = roughness * roughness;
-let oT = ROUGHNESS_MIN * ROUGHNESS_MIN;
-if (anisotropy == 0.0) { return vec2f(max(oT, alpha)); }
+let oX = ROUGHNESS_MIN * ROUGHNESS_MIN;
+if (anisotropy == 0.0) { return vec2f(max(oX, alpha)); }
 let dg = 1.0 - anisotropy;
-let rU = alpha * sqrt(2.0 / (1.0 + dg * dg));
-return max(vec2f(oT), vec2f(rU, dg * rU));
+let rZ = alpha * sqrt(2.0 / (1.0 + dg * dg));
+return max(vec2f(oX), vec2f(rZ, dg * rZ));
 }
 
-fn kx(instanceIndex: i32) -> vec3f {
+fn kA(instanceIndex: i32) -> vec3f {
 if (instanceIndex < 0) { return vec3f(1.0); }
 return instancesBuffer[instanceIndex * ${INSTANCE_VEC4_STRIDE} + 9].xyz;
 }
@@ -130,7 +130,7 @@ let matData = materialsBuffer[materialIndex];
 (*ma).specularRoughness = matData.roughness;
 (*ma).baseMetalness = matData.metallic;
 (*ma).specularAnisotropy = clamp(matData.anisotropy, 0.0, 1.0);
-(*ma).emission = lB(materialIndex, uv, uv1);
+(*ma).emission = lE(materialIndex, uv, uv1);
 (*ma).inside = false;
 (*ma).specularIor = matData.ior;
 (*ma).transmissionWeight = matData.transmission;
@@ -169,19 +169,19 @@ if (USE_DIFFUSE_MAPS) {
 let diffuseMapIndex = i32(matData.diffuseMapIndex);
 if (diffuseMapIndex >= 0) {
 
-let nN = sampleMap(
+let nQ = sampleMap(
 diffuseMapIndex, getMapUvSet(diffuseMapIndex, uv, uv1)
 );
 
 
-(*ma).baseColor *= decodeMapColor(diffuseMapIndex, nN.rgb);
+(*ma).baseColor *= decodeMapColor(diffuseMapIndex, nQ.rgb);
 
 
 if (matData.mapAlphaUsage == ${mapAlphaUsageConstants.transmission}) {
-(*ma).transmissionWeight = 1.0 - nN.a;
+(*ma).transmissionWeight = 1.0 - nQ.a;
 }
 else if (matData.mapAlphaUsage == ${mapAlphaUsageConstants.alpha}) {
-(*ma).alpha *= nN.a;
+(*ma).alpha *= nQ.a;
 }
 }
 }
@@ -232,16 +232,16 @@ ${hasAnisotropyDirections ? /* wgsl */ `
 (*ma).coatAnisotropyRotation = matData.coatAnisotropyRotation;
 if (USE_ANISOTROPY_MAPS && matData.anisotropyMapIndex >= 0.0) {
 let index = i32(matData.anisotropyMapIndex);
-let iW = sampleMap(index, getMapUvSet(index, uv, uv1));
-(*ma).specularAnisotropy *= iW.b;
-let direction = iW.rg * 2.0 - 1.0;
+let iX = sampleMap(index, getMapUvSet(index, uv, uv1));
+(*ma).specularAnisotropy *= iX.b;
+let direction = iX.rg * 2.0 - 1.0;
 if (dot(direction, direction) > 1e-4) { (*ma).anisotropyDirection = normalize(direction); }
 (*ma).anisotropyDirectionEnabled = true;
 }
 if (matData.specularAnisotropyModel > 0.5 && (*ma).specularAnisotropy > 0.0) {
-let sp = fb(clamp((*ma).specularRoughness, 0.0, 1.0), (*ma).specularAnisotropy);
-(*ma).specularRoughness = sp.x;
-(*ma).specularAnisotropy = sp.y;
+let sv = fb(clamp((*ma).specularRoughness, 0.0, 1.0), (*ma).specularAnisotropy);
+(*ma).specularRoughness = sv.x;
+(*ma).specularAnisotropy = sv.y;
 }
 if ((*ma).anisotropyDirectionEnabled) {
 let theta = matData.specularAnisotropyRotation;
@@ -253,55 +253,55 @@ let d = (*ma).anisotropyDirection;
 
 
 if ((*ma).coatWeight > 0.0 && (*ma).coatRoughness > 0.0) {
-let hJ = (*ma).specularRoughness * (*ma).specularRoughness;
-let hK = (*ma).coatRoughness * (*ma).coatRoughness;
+let hI = (*ma).specularRoughness * (*ma).specularRoughness;
+let hJ = (*ma).coatRoughness * (*ma).coatRoughness;
 (*ma).specularRoughness = mix((*ma).specularRoughness,
-pow(min(1.0, hJ * hJ + 2.0 * hK * hK), 0.25), (*ma).coatWeight);
+pow(min(1.0, hI * hI + 2.0 * hJ * hJ), 0.25), (*ma).coatWeight);
 }
-let instanceColor = kx(instanceIndex);
+let instanceColor = kA(instanceIndex);
 (*ma).baseColor *= instanceColor;
 if ((*ma).materialType == UNLIT) { (*ma).emission *= instanceColor; }
 
 (*ma).specularRoughness = clamp((*ma).specularRoughness, ROUGHNESS_MIN, 1.0);
 (*ma).baseMetalness = clamp((*ma).baseMetalness, 0.0, 1.0);
-let specularAlpha = aJ((*ma).specularRoughness, (*ma).specularAnisotropy);
+let specularAlpha = aK((*ma).specularRoughness, (*ma).specularAnisotropy);
 (*ma).alphaX = specularAlpha.x;
 (*ma).alphaY = specularAlpha.y;
 }
 
-fn nY(materialIndex: i32, uv: vec2f, normal: vec3f, dp1: vec3f, dp2: vec3f, nP: vec2f, nQ: vec2f) -> vec3f {
+fn ob(materialIndex: i32, uv: vec2f, normal: vec3f, dp1: vec3f, dp2: vec3f, nS: vec2f, nT: vec2f) -> vec3f {
 let matData = materialsBuffer[materialIndex];
 let normalMapIndex = i32(matData.normalMapIndex);
 if (normalMapIndex >= 0) {
 
 
 
-let qJ = cross(dp2, normal);
-let qI = cross(normal, dp1);
-var dpdu = qJ * nP.x + qI * nQ.x;
-var rZ = qJ * nP.y + qI * nQ.y;
-let dS = max(dot(dpdu, dpdu), dot(rZ, rZ));
+let qO = cross(dp2, normal);
+let qM = cross(normal, dp1);
+var dpdu = qO * nS.x + qM * nT.x;
+var se = qO * nS.y + qM * nT.y;
+let dS = max(dot(dpdu, dpdu), dot(se, se));
 if (dS > 1e-12) {
-let sh = inverseSqrt(dS);
-dpdu *= sh;
-rZ *= sh;
+let sn = inverseSqrt(dS);
+dpdu *= sn;
+se *= sn;
 }
 else {
 
 
-let mZ = select(
+let nf = select(
 vec3f(0.0, 1.0, 0.0),
 vec3f(0.0, 0.0, 1.0),
 abs(normal.z) < 0.999
 );
-dpdu = normalize(cross(mZ, normal));
-rZ = cross(normal, dpdu);
+dpdu = normalize(cross(nf, normal));
+se = cross(normal, dpdu);
 }
 
 var n = 2.0 * sampleMap(normalMapIndex, uv).rgb - 1.0;
 n = normalize(vec3(n.xy * matData.normalMapScale, n.z));
 
-let tbn = mat3x3(dpdu, rZ, normal);
+let tbn = mat3x3(dpdu, se, normal);
 
 return normalize(tbn * n);
 } else {