@meimu/mutracer 0.1.1 → 0.1.3

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

@@ -33,15 +33,15 @@ return vec2(pow((a*a + u*u) * 0.5, 0.25), clamp(1.0 - u/a, 0.0, 1.0));
 
 #endif
 
-vec3 oy(vec3 c) {
+vec3 oB(vec3 c) {
 return mix(pow(c * 0.9478672986 + 0.0521327014, vec3(2.4)), c * 0.0773993808, vec3(lessThan(c, vec3(0.04045))));
 }
 vec4 fetchMatData(int i) {
-return kw(materialBuffer, i, materialBufferColumns);
+return ky(materialBuffer, i, materialBufferColumns);
 }
 
 
-float ld(float alpha, int alphaMode, float alphaCutoff) {
+float lg(float alpha, int alphaMode, float alphaCutoff) {
 if (alphaMode == ${materialAlphaModeConstants.opaque}) {
 return 1.0;
 }
@@ -51,7 +51,7 @@ return alpha >= alphaCutoff ? 1.0 : 0.0;
 return alpha;
 }
 
-float vO(int idx) {
+float vU(int idx) {
 return fetchMatData(idx * MAT_DATA_SIZE + MAT_ROW_COLOR).w;
 }
 
@@ -62,33 +62,33 @@ return vec2(float(val >> 8), float(val & 0xff) / 255.0);
 #ifdef NUM_MAPS
 vec3 decodeMapColor(int index, vec3 c) {
 if (mapColorLinear[index] > 0.5) { return c; }
-return oy(c);
+return oB(c);
 }
 
-vec2 nX(int index) {
+vec2 oa(int index) {
 return mapInfo[index].xy;
 }
 
-float pf(int index) {
+float pj(int index) {
 return floor(mapInfo[index].z);
 }
 
-vec2 nW(int index) {
+vec2 nZ(int index) {
 return vec2(fract(mapInfo[index].z), mapInfo[index].w);
 }
 
-vec2 sb(int index, vec2 uv) {
+vec2 sg(int index, vec2 uv) {
 vec4 transform = mapTransform[index];
-vec2 qv = fract(uv * transform.xy + transform.zw);
-vec2 je = 1.0 / vec2(textureSize(map, 0).xy);
-vec2 dZ = nW(index);
-vec2 ke = nX(index) + je;
-vec2 oB = dZ - 0.5 * je;
-vec2 lo = dZ + ke - je;
+vec2 qz = fract(uv * transform.xy + transform.zw);
+vec2 jg = 1.0 / vec2(textureSize(map, 0).xy);
+vec2 dZ = nZ(index);
+vec2 kg = oa(index) + jg;
+vec2 oE = dZ - 0.5 * jg;
+vec2 lr = dZ + kg - jg;
 return clamp(
-oB + qv * ke,
+oE + qz * kg,
 dZ,
-lo
+lr
 );
 }
 
@@ -97,22 +97,22 @@ return mapUvChannel[index] > 0.5 ? uv1 : uv;
 }
 
 vec4 sampleMap(int index, vec2 uv) {
-return texture(map, vec3(sb(index, uv), pf(index)));
+return texture(map, vec3(sg(index, uv), pj(index)));
 }
 #endif
 
 
-vec2 aJ(float roughness, float anisotropy) {
+vec2 aK(float roughness, float anisotropy) {
 float alpha = roughness * roughness;
-float oT = ROUGHNESS_MIN * ROUGHNESS_MIN;
-if (anisotropy == 0.0) { return vec2(max(oT, alpha)); }
+float oX = ROUGHNESS_MIN * ROUGHNESS_MIN;
+if (anisotropy == 0.0) { return vec2(max(oX, alpha)); }
 float dg = 1.0 - anisotropy;
-float rU = alpha * sqrt(2.0 / (1.0 + dg * dg));
-return max(vec2(oT), vec2(rU, dg * rU));
+float rZ = alpha * sqrt(2.0 / (1.0 + dg * dg));
+return max(vec2(oX), vec2(rZ, dg * rZ));
 }
 
 vec4 bv(int i);
-vec3 kx(int instanceIndex) {
+vec3 kA(int instanceIndex) {
 if (instanceIndex < 0) return vec3(1.0);
 return bv(instanceIndex * ${INSTANCE_VEC4_STRIDE + ''} + 9).rgb;
 }
@@ -125,62 +125,62 @@ vec2 uv1,
 int instanceIndex
 ) {
 int i = materialIndex * MAT_DATA_SIZE;
-vec4 oJ = fetchMatData(i + MAT_ROW_COLOR);
-vec4 hb = fetchMatData(i + MAT_ROW_ROUGHNESS_NORMAL);
-vec4 gh = fetchMatData(i + MAT_ROW_METALLIC_MAPS);
-vec4 hF = fetchMatData(i + MAT_ROW_EMISSION);
-vec4 gT = fetchMatData(i + MAT_ROW_IOR_TRANSMISSION);
+vec4 oM = fetchMatData(i + MAT_ROW_COLOR);
+vec4 hc = fetchMatData(i + MAT_ROW_ROUGHNESS_NORMAL);
+vec4 gi = fetchMatData(i + MAT_ROW_METALLIC_MAPS);
+vec4 hE = fetchMatData(i + MAT_ROW_EMISSION);
+vec4 gU = fetchMatData(i + MAT_ROW_IOR_TRANSMISSION);
 vec4 misc = fetchMatData(i + MAT_ROW_MISC);
-vec4 nh = fetchMatData(i + MAT_ROW_ALPHA_FILM);
-vec4 lF = fetchMatData(i + MAT_ROW_BASE_CONTROLS);
-vec4 oM = fetchMatData(i + MAT_ROW_SPECULAR_FUZZ);
+vec4 nk = fetchMatData(i + MAT_ROW_ALPHA_FILM);
+vec4 lI = fetchMatData(i + MAT_ROW_BASE_CONTROLS);
+vec4 oQ = fetchMatData(i + MAT_ROW_SPECULAR_FUZZ);
 vec4 subsurface = fetchMatData(i + MAT_ROW_SUBSURFACE);
-vec4 wc = fetchMatData(i + MAT_ROW_FUZZ);
-vec4 vx = fetchMatData(i + MAT_ROW_COAT);
-vec4 lG = fetchMatData(i + MAT_ROW_COAT_CONTROLS);
-vec4 mK = fetchMatData(i + MAT_ROW_FILM_DISPERSION);
-vec4 ng = fetchMatData(i + MAT_ROW_STANDALONE_MAPS);
+vec4 wj = fetchMatData(i + MAT_ROW_FUZZ);
+vec4 vE = fetchMatData(i + MAT_ROW_COAT);
+vec4 lJ = fetchMatData(i + MAT_ROW_COAT_CONTROLS);
+vec4 mN = fetchMatData(i + MAT_ROW_FILM_DISPERSION);
+vec4 nj = fetchMatData(i + MAT_ROW_STANDALONE_MAPS);
 int mapAlphaUsage = int(misc.a);
 
-mat.baseColor = oJ.rgb;
-mat.materialType = int(oJ.w);
-mat.specularRoughness = hb.x;
-mat.baseMetalness = gh.x;
-mat.specularAnisotropy = clamp(gh.y, 0.0, 1.0);
-mat.emission = hF.rgb;
+mat.baseColor = oM.rgb;
+mat.materialType = int(oM.w);
+mat.specularRoughness = hc.x;
+mat.baseMetalness = gi.x;
+mat.specularAnisotropy = clamp(gi.y, 0.0, 1.0);
+mat.emission = hE.rgb;
 mat.inside = false;
-mat.specularIor = gT.x;
-mat.transmissionWeight = gT.y;
+mat.specularIor = gU.x;
+mat.transmissionWeight = gU.y;
 #ifdef HAS_MEDIUM
-mat.mediumType = int(gT.z);
+mat.mediumType = int(gU.z);
 #else
 mat.mediumType = 0;
 #endif
-mat.thinWalled = gT.w > 0.5;
+mat.thinWalled = gU.w > 0.5;
 mat.bevel = misc.r;
 mat.transmissionDispersionScale = misc.g;
-mat.dispersionAbbeNumber = max(mK.y, 1e-6);
+mat.dispersionAbbeNumber = max(mN.y, 1e-6);
 mat.thinFilmThickness = misc.b;
-mat.thinFilmIor = nh.b;
-mat.thinFilmWeight = clamp(mK.x, 0.0, 1.0);
+mat.thinFilmIor = nk.b;
+mat.thinFilmWeight = clamp(mN.x, 0.0, 1.0);
 
 mat.thinFilmThickness *= 1000.0;
-mat.baseWeight = clamp(lF.x, 0.0, 1.0);
-mat.diffuseRoughness = clamp(lF.y, 0.0, 1.0);
-mat.specularWeight = max(0.0, lF.z);
-mat.subsurfaceWeight = clamp(lF.w, 0.0, 1.0);
-mat.specularColor = max(oM.rgb, vec3(0.0));
-mat.fuzzWeight = clamp(oM.w, 0.0, 1.0);
+mat.baseWeight = clamp(lI.x, 0.0, 1.0);
+mat.diffuseRoughness = clamp(lI.y, 0.0, 1.0);
+mat.specularWeight = max(0.0, lI.z);
+mat.subsurfaceWeight = clamp(lI.w, 0.0, 1.0);
+mat.specularColor = max(oQ.rgb, vec3(0.0));
+mat.fuzzWeight = clamp(oQ.w, 0.0, 1.0);
 mat.subsurfaceColor = max(subsurface.rgb, vec3(0.0));
 mat.transmissionColor = max(fetchMatData(i + MAT_ROW_TRANSMISSION_COLOR).rgb, vec3(0.0));
-mat.fuzzColor = max(wc.rgb, vec3(0.0));
-mat.fuzzRoughness = clamp(wc.w, 0.0, 1.0);
-mat.coatColor = max(vx.rgb, vec3(0.0));
-mat.coatWeight = clamp(vx.w, 0.0, 1.0);
-mat.coatRoughness = clamp(lG.x, ROUGHNESS_MIN, 1.0);
-mat.coatAnisotropy = clamp(lG.y, 0.0, 1.0);
-mat.coatIor = max(lG.z, 1.0);
-mat.coatDarkening = clamp(lG.w, 0.0, 1.0);
+mat.fuzzColor = max(wj.rgb, vec3(0.0));
+mat.fuzzRoughness = clamp(wj.w, 0.0, 1.0);
+mat.coatColor = max(vE.rgb, vec3(0.0));
+mat.coatWeight = clamp(vE.w, 0.0, 1.0);
+mat.coatRoughness = clamp(lJ.x, ROUGHNESS_MIN, 1.0);
+mat.coatAnisotropy = clamp(lJ.y, 0.0, 1.0);
+mat.coatIor = max(lJ.z, 1.0);
+mat.coatDarkening = clamp(lJ.w, 0.0, 1.0);
 
 #ifdef HAS_MEDIUM
 mat.mediumExtinction = max(fetchMatData(i + MAT_ROW_MEDIUM_EXTINCTION).rgb, vec3(0.0));
@@ -191,41 +191,41 @@ mat.mediumType = max(max(mat.mediumExtinction.x, mat.mediumExtinction.y), mat.me
 
 
 #ifdef HAS_ALPHA
-mat.alpha = nh.r;
+mat.alpha = nk.r;
 #else
 mat.alpha = 1.0;
 #endif
 
 #ifdef NUM_DIFFUSE_MAPS
-int diffuseMapIndex = int(gh.z);
+int diffuseMapIndex = int(gi.z);
 if (diffuseMapIndex >= 0) {
-vec4 nN = sampleMap(
+vec4 nQ = sampleMap(
 diffuseMapIndex, getMapUvSet(diffuseMapIndex, uv, uv1)
 );
 
 
-mat.baseColor *= decodeMapColor(diffuseMapIndex, nN.rgb);
+mat.baseColor *= decodeMapColor(diffuseMapIndex, nQ.rgb);
 
 
 if (mapAlphaUsage == ${mapAlphaUsageConstants.transmission + ''}) {
-mat.transmissionWeight = 1.0 - nN.a;
+mat.transmissionWeight = 1.0 - nQ.a;
 }
 else if (mapAlphaUsage == ${mapAlphaUsageConstants.alpha + ''}) {
-mat.alpha *= nN.a;
+mat.alpha *= nQ.a;
 }
 }
 #endif
 
 ${simpleTextureSample('alphaMap', 'glsl')}
 
-mat.alpha = ld(
-mat.alpha, int(fetchMatData(i + MAT_ROW_ALPHA).w), ng.w
+mat.alpha = lg(
+mat.alpha, int(fetchMatData(i + MAT_ROW_ALPHA).w), nj.w
 );
 
 ${simpleTextureSample('transmissionMap', 'glsl')}
 
 #ifdef NUM_METALLIC_ROUGHNESS_MAPS
-int metallicRoughnessMapIndex = int(gh.w);
+int metallicRoughnessMapIndex = int(gi.w);
 if (metallicRoughnessMapIndex >= 0) {
 vec4 fK = sampleMap(
 metallicRoughnessMapIndex,
@@ -241,7 +241,7 @@ ${simpleTextureSample('roughnessMap', 'glsl')}
 ${simpleTextureSample('metalnessMap', 'glsl')}
 
 #ifdef NUM_EMISSIVE_MAPS
-int emissiveMapIndex = int(hF.w);
+int emissiveMapIndex = int(hE.w);
 if (emissiveMapIndex >= 0) {
 vec3 emissive = sampleMap(
 emissiveMapIndex, getMapUvSet(emissiveMapIndex, uv, uv1)
@@ -251,12 +251,12 @@ mat.emission *= decodeMapColor(emissiveMapIndex, emissive);
 #endif
 
 #ifdef NUM_COAT_WEIGHT_MAPS
-int hN = int(fetchMatData(i + MAT_ROW_LAYER_MAPS).x);
-if (hN >= 0 && mat.materialType == 0) {
-float qk = clamp(vx.w, 0.0, 1.0) * sampleMap(
-hN, getMapUvSet(hN, uv, uv1)
+int hM = int(fetchMatData(i + MAT_ROW_LAYER_MAPS).x);
+if (hM >= 0 && mat.materialType == 0) {
+float qo = clamp(vE.w, 0.0, 1.0) * sampleMap(
+hM, getMapUvSet(hM, uv, uv1)
 ).r;
-mat.emission *= mix(vec3(1.0), sqrt(max(vx.rgb, vec3(0.0))), qk);
+mat.emission *= mix(vec3(1.0), sqrt(max(vE.rgb, vec3(0.0))), qo);
 }
 #endif
 
@@ -277,29 +277,29 @@ ${simpleTextureSample('specularWeightMap', 'glsl')}
 
 ${simpleTextureSample('specularColorMap', 'glsl')}
 
-vec4 kK = fetchMatData(i + MAT_ROW_DIRECTION_NORMAL);
+vec4 kN = fetchMatData(i + MAT_ROW_DIRECTION_NORMAL);
 mat.anisotropyDirection = vec2(1.0, 0.0);
-mat.anisotropyDirectionEnabled = kK.y != 0.0;
+mat.anisotropyDirectionEnabled = kN.y != 0.0;
 mat.coatAnisotropyRotation = fetchMatData(i + MAT_ROW_FILM_TEXTURE).x;
 #ifdef NUM_ANISOTROPY_MAPS
-if (kK.x >= 0.0) {
-int index = int(kK.x);
-vec4 iW = sampleMap(index, getMapUvSet(index, uv, uv1));
-mat.specularAnisotropy *= iW.b;
-vec2 direction = iW.rg * 2.0 - 1.0;
+if (kN.x >= 0.0) {
+int index = int(kN.x);
+vec4 iX = sampleMap(index, getMapUvSet(index, uv, uv1));
+mat.specularAnisotropy *= iX.b;
+vec2 direction = iX.rg * 2.0 - 1.0;
 if (dot(direction, direction) > 1e-4) mat.anisotropyDirection = normalize(direction);
 mat.anisotropyDirectionEnabled = true;
 }
 #endif
 #ifdef HAS_GLTF_ANISOTROPY
 if (fetchMatData(i + MAT_ROW_FILM_TEXTURE).y > 0.5 && mat.specularAnisotropy > 0.0) {
-vec2 sp = fb(clamp(mat.specularRoughness, 0.0, 1.0), mat.specularAnisotropy);
-mat.specularRoughness = sp.x;
-mat.specularAnisotropy = sp.y;
+vec2 sv = fb(clamp(mat.specularRoughness, 0.0, 1.0), mat.specularAnisotropy);
+mat.specularRoughness = sv.x;
+mat.specularAnisotropy = sv.y;
 }
 #endif
 if (mat.anisotropyDirectionEnabled) {
-float theta = kK.y;
+float theta = kN.y;
 vec2 d = mat.anisotropyDirection;
 mat.anisotropyDirection = vec2(cos(theta)*d.x - sin(theta)*d.y, sin(theta)*d.x + cos(theta)*d.y);
 }
@@ -307,57 +307,57 @@ mat.anisotropyDirection = vec2(cos(theta)*d.x - sin(theta)*d.y, sin(theta)*d.x +
 
 
 if (mat.coatWeight > 0.0 && mat.coatRoughness > 0.0) {
-float hJ = mat.specularRoughness * mat.specularRoughness;
-float hK = mat.coatRoughness * mat.coatRoughness;
+float hI = mat.specularRoughness * mat.specularRoughness;
+float hJ = mat.coatRoughness * mat.coatRoughness;
 mat.specularRoughness = mix(mat.specularRoughness,
-pow(min(1.0, hJ * hJ + 2.0 * hK * hK), 0.25), mat.coatWeight);
+pow(min(1.0, hI * hI + 2.0 * hJ * hJ), 0.25), mat.coatWeight);
 }
-vec3 instanceColor = kx(instanceIndex);
+vec3 instanceColor = kA(instanceIndex);
 mat.baseColor *= instanceColor;
 if (mat.materialType == UNLIT) mat.emission *= instanceColor;
 
 mat.specularRoughness = clamp(mat.specularRoughness, ROUGHNESS_MIN, 1.0);
 mat.baseMetalness = clamp(mat.baseMetalness, 0.0, 1.0);
-vec2 specularAlpha = aJ(mat.specularRoughness, mat.specularAnisotropy);
+vec2 specularAlpha = aK(mat.specularRoughness, mat.specularAnisotropy);
 mat.alphaX = specularAlpha.x;
 mat.alphaY = specularAlpha.y;
 }
 
 #if defined(NUM_NORMAL_MAPS)
-vec3 nY(int materialIndex, vec2 uv, vec3 normal, vec3 dp1, vec3 dp2, vec2 nP, vec2 nQ) {
+vec3 ob(int materialIndex, vec2 uv, vec3 normal, vec3 dp1, vec3 dp2, vec2 nS, vec2 nT) {
 int i = materialIndex * MAT_DATA_SIZE;
-vec4 hb = fetchMatData(i + MAT_ROW_ROUGHNESS_NORMAL);
-int normalMapIndex = int(hb.y);
+vec4 hc = fetchMatData(i + MAT_ROW_ROUGHNESS_NORMAL);
+int normalMapIndex = int(hc.y);
 if (normalMapIndex >= 0) {
 
 
 
-vec3 qJ = cross(dp2, normal);
-vec3 qI = cross(normal, dp1);
-vec3 dpdu = qJ * nP.x + qI * nQ.x;
-vec3 rZ = qJ * nP.y + qI * nQ.y;
-float dS = max(dot(dpdu, dpdu), dot(rZ, rZ));
+vec3 qO = cross(dp2, normal);
+vec3 qM = cross(normal, dp1);
+vec3 dpdu = qO * nS.x + qM * nT.x;
+vec3 se = qO * nS.y + qM * nT.y;
+float dS = max(dot(dpdu, dpdu), dot(se, se));
 if (dS > 1e-12) {
-float sh = inversesqrt(dS);
-dpdu *= sh;
-rZ *= sh;
+float sn = inversesqrt(dS);
+dpdu *= sn;
+se *= sn;
 }
 else {
 
 
 
-vec3 mZ = abs(normal.z) < 0.999
+vec3 nf = abs(normal.z) < 0.999
 ? vec3(0.0, 0.0, 1.0)
 : vec3(0.0, 1.0, 0.0);
-dpdu = normalize(cross(mZ, normal));
-rZ = cross(normal, dpdu);
+dpdu = normalize(cross(nf, normal));
+se = cross(normal, dpdu);
 }
 
 vec3 n = 2.0 * sampleMap(normalMapIndex, uv).rgb - 1.0;
-n.xy *= hb.zw;
+n.xy *= hc.zw;
 n = normalize(n);
 
-mat3 tbn = mat3(dpdu, rZ, normal);
+mat3 tbn = mat3(dpdu, se, normal);
 
 return normalize(tbn * n);
 } else {