@meimu/mutracer 0.1.3 → 0.1.5

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

@@ -15,6 +15,7 @@ export default createShaderMixin({
         mapTransform: Shader.arrayUniform('vec4', 'NUM_MAPS'),
         mapUvChannel: Shader.arrayUniform('float', 'NUM_MAPS'),
         mapColorLinear: Shader.arrayUniform('float', 'NUM_MAPS'),
+        mapWrap: Shader.arrayUniform('vec2', 'NUM_MAPS'),
         map: Shader.uniform('sampler2DArray')
     },
     defines: {
@@ -23,7 +24,7 @@ export default createShaderMixin({
     main: glsl `
 ${materialRowsGlsl()}
 #ifdef HAS_GLTF_ANISOTROPY
-vec2 fb(float roughness, float strength) {
+vec2 fe(float roughness, float strength) {
 if (strength == 0.0) { return vec2(roughness, 0.0); }
 float u = roughness * roughness;
 float a = u + (1.0 - u) * strength * strength;
@@ -33,15 +34,15 @@ return vec2(pow((a*a + u*u) * 0.5, 0.25), clamp(1.0 - u/a, 0.0, 1.0));
 
 #endif
 
-vec3 oB(vec3 c) {
+vec3 oJ(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 ky(materialBuffer, i, materialBufferColumns);
+return kG(materialBuffer, i, materialBufferColumns);
 }
 
 
-float lg(float alpha, int alphaMode, float alphaCutoff) {
+float lr(float alpha, int alphaMode, float alphaCutoff) {
 if (alphaMode == ${materialAlphaModeConstants.opaque}) {
 return 1.0;
 }
@@ -51,7 +52,7 @@ return alpha >= alphaCutoff ? 1.0 : 0.0;
 return alpha;
 }
 
-float vU(int idx) {
+float wb(int idx) {
 return fetchMatData(idx * MAT_DATA_SIZE + MAT_ROW_COLOR).w;
 }
 
@@ -62,33 +63,44 @@ 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 oB(c);
+return oJ(c);
 }
 
-vec2 oa(int index) {
+vec2 kJ(int index) {
 return mapInfo[index].xy;
 }
 
-float pj(int index) {
+float lk(int index) {
 return floor(mapInfo[index].z);
 }
 
-vec2 nZ(int index) {
+vec2 jP(int index) {
 return vec2(fract(mapInfo[index].z), mapInfo[index].w);
 }
 
-vec2 sg(int index, vec2 uv) {
+float fT(float value, float mode) {
+if (mode < 0.5) return fract(value);
+if (mode < 1.5) return clamp(value, 0.0, 1.0);
+return 1.0 - abs(1.0 - (value - 2.0 * floor(value * 0.5)));
+}
+
+vec2 kv(int index, vec2 uv) {
 vec4 transform = mapTransform[index];
-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;
+vec2 value = uv * transform.xy + transform.zw;
+return vec2(fT(value.x, mapWrap[index].x), fT(value.y, mapWrap[index].y));
+}
+
+vec2 sq(int index, vec2 uv) {
+vec2 qH = kv(index, uv);
+vec2 jk = 1.0 / vec2(textureSize(map, 0).xy);
+vec2 dZ = jP(index);
+vec2 kn = kJ(index) + jk;
+vec2 oM = dZ - 0.5 * jk;
+vec2 lD = dZ + kn - jk;
 return clamp(
-oE + qz * kg,
+oM + qH * kn,
 dZ,
-lr
+lD
 );
 }
 
@@ -96,91 +108,111 @@ vec2 getMapUvSet(int index, vec2 uv, vec2 uv1) {
 return mapUvChannel[index] > 0.5 ? uv1 : uv;
 }
 
+vec4 eU(int index, ivec2 jm, ivec2 size, ivec2 origin, vec2 iK) {
+ivec2 p = clamp(jm, ivec2(0), size - 1);
+if (iK.x < 0.5) p.x = ((jm.x % size.x) + size.x) % size.x;
+if (iK.y < 0.5) p.y = ((jm.y % size.y) + size.y) % size.y;
+return texelFetch(map, ivec3(origin + p, int(lk(index))), 0);
+}
+
 vec4 sampleMap(int index, vec2 uv) {
-return texture(map, vec3(sg(index, uv), pj(index)));
+ivec2 size = ivec2(round(kJ(index) * vec2(textureSize(map, 0).xy) + 1.0));
+vec2 eA = kv(index, uv) * vec2(size) - 0.5;
+vec2 iK = mapWrap[index];
+if ((size.x > 1 && iK.x < 0.5 && (eA.x < 0.0 || eA.x > float(size.x - 1))) ||
+(size.y > 1 && iK.y < 0.5 && (eA.y < 0.0 || eA.y > float(size.y - 1)))) {
+ivec2 base = ivec2(floor(eA));
+vec2 weight = fract(eA);
+ivec2 origin = ivec2(round(jP(index) * vec2(textureSize(map, 0).xy) - 0.5));
+return mix(
+mix(eU(index, base, size, origin, iK), eU(index, base + ivec2(1, 0), size, origin, iK), weight.x),
+mix(eU(index, base + ivec2(0, 1), size, origin, iK), eU(index, base + ivec2(1, 1), size, origin, iK), weight.x), weight.y);
+}
+return texture(map, vec3(sq(index, uv), lk(index)));
 }
 #endif
 
 
 vec2 aK(float roughness, float anisotropy) {
 float alpha = roughness * roughness;
-float oX = ROUGHNESS_MIN * ROUGHNESS_MIN;
-if (anisotropy == 0.0) { return vec2(max(oX, alpha)); }
-float dg = 1.0 - anisotropy;
-float rZ = alpha * sqrt(2.0 / (1.0 + dg * dg));
-return max(vec2(oX), vec2(rZ, dg * rZ));
+float pg = ROUGHNESS_MIN * ROUGHNESS_MIN;
+if (anisotropy == 0.0) { return vec2(max(pg, alpha)); }
+float di = 1.0 - anisotropy;
+float sh = alpha * sqrt(2.0 / (1.0 + di * di));
+return max(vec2(pg), vec2(sh, di * sh));
 }
 
 vec4 bv(int i);
-vec3 kA(int instanceIndex) {
+vec3 kI(int instanceIndex) {
 if (instanceIndex < 0) return vec3(1.0);
 return bv(instanceIndex * ${INSTANCE_VEC4_STRIDE + ''} + 9).rgb;
 }
 
-void eT(
+void eX(
 inout J mat,
 int materialIndex,
 vec2 uv,
 vec2 uv1,
-int instanceIndex
+int instanceIndex,
+vec3 vertexColor
 ) {
 int i = materialIndex * MAT_DATA_SIZE;
-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 oV = fetchMatData(i + MAT_ROW_COLOR);
+vec4 fo = fetchMatData(i + MAT_ROW_ROUGHNESS_NORMAL);
+vec4 gp = fetchMatData(i + MAT_ROW_METALLIC_MAPS);
+vec4 hI = fetchMatData(i + MAT_ROW_EMISSION);
+vec4 gZ = fetchMatData(i + MAT_ROW_IOR_TRANSMISSION);
 vec4 misc = fetchMatData(i + MAT_ROW_MISC);
-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 nB = fetchMatData(i + MAT_ROW_ALPHA_FILM);
+vec4 lR = fetchMatData(i + MAT_ROW_BASE_CONTROLS);
+vec4 oZ = fetchMatData(i + MAT_ROW_SPECULAR_FUZZ);
 vec4 subsurface = fetchMatData(i + MAT_ROW_SUBSURFACE);
-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);
+vec4 wq = fetchMatData(i + MAT_ROW_FUZZ);
+vec4 vL = fetchMatData(i + MAT_ROW_COAT);
+vec4 lS = fetchMatData(i + MAT_ROW_COAT_CONTROLS);
+vec4 mX = fetchMatData(i + MAT_ROW_FILM_DISPERSION);
+vec4 nA = fetchMatData(i + MAT_ROW_STANDALONE_MAPS);
 int mapAlphaUsage = int(misc.a);
 
-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.baseColor = oV.rgb;
+mat.materialType = int(oV.w);
+mat.specularRoughness = fo.x;
+mat.baseMetalness = gp.x;
+mat.specularAnisotropy = clamp(gp.y, 0.0, 1.0);
+mat.emission = hI.rgb;
 mat.inside = false;
-mat.specularIor = gU.x;
-mat.transmissionWeight = gU.y;
+mat.specularIor = gZ.x;
+mat.transmissionWeight = gZ.y;
 #ifdef HAS_MEDIUM
-mat.mediumType = int(gU.z);
+mat.mediumType = int(gZ.z);
 #else
 mat.mediumType = 0;
 #endif
-mat.thinWalled = gU.w > 0.5;
+mat.thinWalled = gZ.w > 0.5;
 mat.bevel = misc.r;
 mat.transmissionDispersionScale = misc.g;
-mat.dispersionAbbeNumber = max(mN.y, 1e-6);
+mat.dispersionAbbeNumber = max(mX.y, 1e-6);
 mat.thinFilmThickness = misc.b;
-mat.thinFilmIor = nk.b;
-mat.thinFilmWeight = clamp(mN.x, 0.0, 1.0);
+mat.thinFilmIor = nB.b;
+mat.thinFilmWeight = clamp(mX.x, 0.0, 1.0);
 
 mat.thinFilmThickness *= 1000.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.baseWeight = clamp(lR.x, 0.0, 1.0);
+mat.diffuseRoughness = clamp(lR.y, 0.0, 1.0);
+mat.specularWeight = max(0.0, lR.z);
+mat.subsurfaceWeight = clamp(lR.w, 0.0, 1.0);
+mat.specularColor = max(oZ.rgb, vec3(0.0));
+mat.fuzzWeight = clamp(oZ.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(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);
+mat.fuzzColor = max(wq.rgb, vec3(0.0));
+mat.fuzzRoughness = clamp(wq.w, 0.0, 1.0);
+mat.coatColor = max(vL.rgb, vec3(0.0));
+mat.coatWeight = clamp(vL.w, 0.0, 1.0);
+mat.coatRoughness = clamp(lS.x, ROUGHNESS_MIN, 1.0);
+mat.coatAnisotropy = clamp(lS.y, 0.0, 1.0);
+mat.coatIor = max(lS.z, 1.0);
+mat.coatDarkening = clamp(lS.w, 0.0, 1.0);
 
 #ifdef HAS_MEDIUM
 mat.mediumExtinction = max(fetchMatData(i + MAT_ROW_MEDIUM_EXTINCTION).rgb, vec3(0.0));
@@ -191,48 +223,48 @@ mat.mediumType = max(max(mat.mediumExtinction.x, mat.mediumExtinction.y), mat.me
 
 
 #ifdef HAS_ALPHA
-mat.alpha = nk.r;
+mat.alpha = nB.r;
 #else
 mat.alpha = 1.0;
 #endif
 
 #ifdef NUM_DIFFUSE_MAPS
-int diffuseMapIndex = int(gi.z);
+int diffuseMapIndex = int(gp.z);
 if (diffuseMapIndex >= 0) {
-vec4 nQ = sampleMap(
+vec4 oa = sampleMap(
 diffuseMapIndex, getMapUvSet(diffuseMapIndex, uv, uv1)
 );
 
 
-mat.baseColor *= decodeMapColor(diffuseMapIndex, nQ.rgb);
+mat.baseColor *= decodeMapColor(diffuseMapIndex, oa.rgb);
 
 
 if (mapAlphaUsage == ${mapAlphaUsageConstants.transmission + ''}) {
-mat.transmissionWeight = 1.0 - nQ.a;
+mat.transmissionWeight = 1.0 - oa.a;
 }
 else if (mapAlphaUsage == ${mapAlphaUsageConstants.alpha + ''}) {
-mat.alpha *= nQ.a;
+mat.alpha *= oa.a;
 }
 }
 #endif
 
 ${simpleTextureSample('alphaMap', 'glsl')}
 
-mat.alpha = lg(
-mat.alpha, int(fetchMatData(i + MAT_ROW_ALPHA).w), nj.w
+mat.alpha = lr(
+mat.alpha, int(fetchMatData(i + MAT_ROW_ALPHA).w), nA.w
 );
 
 ${simpleTextureSample('transmissionMap', 'glsl')}
 
 #ifdef NUM_METALLIC_ROUGHNESS_MAPS
-int metallicRoughnessMapIndex = int(gi.w);
+int metallicRoughnessMapIndex = int(gp.w);
 if (metallicRoughnessMapIndex >= 0) {
-vec4 fK = sampleMap(
+vec4 fO = sampleMap(
 metallicRoughnessMapIndex,
 getMapUvSet(metallicRoughnessMapIndex, uv, uv1)
 );
-mat.baseMetalness *= fK.b;
-mat.specularRoughness *= fK.g;
+mat.baseMetalness *= fO.b;
+mat.specularRoughness *= fO.g;
 }
 #endif
 
@@ -241,7 +273,7 @@ ${simpleTextureSample('roughnessMap', 'glsl')}
 ${simpleTextureSample('metalnessMap', 'glsl')}
 
 #ifdef NUM_EMISSIVE_MAPS
-int emissiveMapIndex = int(hE.w);
+int emissiveMapIndex = int(hI.w);
 if (emissiveMapIndex >= 0) {
 vec3 emissive = sampleMap(
 emissiveMapIndex, getMapUvSet(emissiveMapIndex, uv, uv1)
@@ -251,20 +283,21 @@ mat.emission *= decodeMapColor(emissiveMapIndex, emissive);
 #endif
 
 #ifdef NUM_COAT_WEIGHT_MAPS
-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)
+int hQ = int(fetchMatData(i + MAT_ROW_LAYER_MAPS).x);
+if (hQ >= 0 && mat.materialType == 0) {
+float qw = clamp(vL.w, 0.0, 1.0) * sampleMap(
+hQ, getMapUvSet(hQ, uv, uv1)
 ).r;
-mat.emission *= mix(vec3(1.0), sqrt(max(vE.rgb, vec3(0.0))), qo);
+mat.emission *= mix(vec3(1.0), sqrt(max(vL.rgb, vec3(0.0))), qw);
 }
 #endif
 
 ${thinFilmTextureSample('glsl')}
 
 ${simpleTextureSample('coatWeightMap', 'glsl')}
-#ifdef NUM_COAT_NORMAL_MAPS
-mat.coatNormalEnabled = fetchMatData(i + MAT_ROW_LAYER_MAPS).z >= 0.0 && mat.coatWeight > 0.0;
+#ifdef USE_COAT_NORMAL_FRAMES
+
+mat.coatNormalEnabled = mat.coatWeight > 0.0 && (fo.y >= 0.0 || fetchMatData(i + MAT_ROW_LAYER_MAPS).z >= 0.0);
 #endif
 
 ${simpleTextureSample('coatRoughnessMap', 'glsl')}
@@ -277,29 +310,29 @@ ${simpleTextureSample('specularWeightMap', 'glsl')}
 
 ${simpleTextureSample('specularColorMap', 'glsl')}
 
-vec4 kN = fetchMatData(i + MAT_ROW_DIRECTION_NORMAL);
+vec4 kW = fetchMatData(i + MAT_ROW_DIRECTION_NORMAL);
 mat.anisotropyDirection = vec2(1.0, 0.0);
-mat.anisotropyDirectionEnabled = kN.y != 0.0;
+mat.anisotropyDirectionEnabled = kW.y != 0.0;
 mat.coatAnisotropyRotation = fetchMatData(i + MAT_ROW_FILM_TEXTURE).x;
 #ifdef NUM_ANISOTROPY_MAPS
-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 (kW.x >= 0.0) {
+int index = int(kW.x);
+vec4 eA = sampleMap(index, getMapUvSet(index, uv, uv1));
+mat.specularAnisotropy *= eA.b;
+vec2 direction = eA.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 sv = fb(clamp(mat.specularRoughness, 0.0, 1.0), mat.specularAnisotropy);
-mat.specularRoughness = sv.x;
-mat.specularAnisotropy = sv.y;
+vec2 sF = fe(clamp(mat.specularRoughness, 0.0, 1.0), mat.specularAnisotropy);
+mat.specularRoughness = sF.x;
+mat.specularAnisotropy = sF.y;
 }
 #endif
 if (mat.anisotropyDirectionEnabled) {
-float theta = kN.y;
+float theta = kW.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,14 +340,14 @@ 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 hI = mat.specularRoughness * mat.specularRoughness;
-float hJ = mat.coatRoughness * mat.coatRoughness;
+float hM = mat.specularRoughness * mat.specularRoughness;
+float hN = mat.coatRoughness * mat.coatRoughness;
 mat.specularRoughness = mix(mat.specularRoughness,
-pow(min(1.0, hI * hI + 2.0 * hJ * hJ), 0.25), mat.coatWeight);
+pow(min(1.0, hM * hM + 2.0 * hN * hN), 0.25), mat.coatWeight);
 }
-vec3 instanceColor = kA(instanceIndex);
-mat.baseColor *= instanceColor;
-if (mat.materialType == UNLIT) mat.emission *= instanceColor;
+vec3 color = kI(instanceIndex) * vertexColor;
+mat.baseColor *= color;
+if (mat.materialType == UNLIT) mat.emission *= color;
 
 mat.specularRoughness = clamp(mat.specularRoughness, ROUGHNESS_MIN, 1.0);
 mat.baseMetalness = clamp(mat.baseMetalness, 0.0, 1.0);
@@ -324,40 +357,40 @@ mat.alphaY = specularAlpha.y;
 }
 
 #if defined(NUM_NORMAL_MAPS)
-vec3 ob(int materialIndex, vec2 uv, vec3 normal, vec3 dp1, vec3 dp2, vec2 nS, vec2 nT) {
+vec3 ol(int materialIndex, vec2 uv, vec3 normal, vec3 dp1, vec3 dp2, vec2 oc, vec2 od) {
 int i = materialIndex * MAT_DATA_SIZE;
-vec4 hc = fetchMatData(i + MAT_ROW_ROUGHNESS_NORMAL);
-int normalMapIndex = int(hc.y);
+vec4 fo = fetchMatData(i + MAT_ROW_ROUGHNESS_NORMAL);
+int normalMapIndex = int(fo.y);
 if (normalMapIndex >= 0) {
 
 
 
-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 sn = inversesqrt(dS);
-dpdu *= sn;
-se *= sn;
+vec3 qW = cross(dp2, normal);
+vec3 qV = cross(normal, dp1);
+vec3 dpdu = qW * oc.x + qV * od.x;
+vec3 sn = qW * oc.y + qV * od.y;
+float dT = max(dot(dpdu, dpdu), dot(sn, sn));
+if (dT > 1e-12) {
+float sz = inversesqrt(dT);
+dpdu *= sz;
+sn *= sz;
 }
 else {
 
 
 
-vec3 nf = abs(normal.z) < 0.999
+vec3 ns = abs(normal.z) < 0.999
 ? vec3(0.0, 0.0, 1.0)
 : vec3(0.0, 1.0, 0.0);
-dpdu = normalize(cross(nf, normal));
-se = cross(normal, dpdu);
+dpdu = normalize(cross(ns, normal));
+sn = cross(normal, dpdu);
 }
 
 vec3 n = 2.0 * sampleMap(normalMapIndex, uv).rgb - 1.0;
-n.xy *= hc.zw;
+n.xy *= fo.zw;
 n = normalize(n);
 
-mat3 tbn = mat3(dpdu, se, normal);
+mat3 tbn = mat3(dpdu, sn, normal);
 
 return normalize(tbn * n);
 } else {

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

@@ -1 +1 @@
-{"version":3,"file":"materialBuffer.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/materialBuffer.glsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAC3F,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAElE,eAAe,iBAAiB,CAAC;IAC/B,QAAQ,EAAE;QACR,cAAc,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QAC3C,qBAAqB,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;QAC/C,OAAO,EAAE,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,UAAU,CAAC;QAChD,YAAY,EAAE,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,UAAU,CAAC;QACrD,YAAY,EAAE,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,UAAU,CAAC;QACtD,cAAc,EAAE,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,UAAU,CAAC;QACxD,GAAG,EAAE,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC;KACtC;IACD,OAAO,EAAE;QACP,aAAa,EAAE,CAAC;KACjB;IACD,IAAI,EAAE,IAAI,CAAA;EACV,gBAAgB,EAAE;;;;;;;;;;;;;;;;;;;;;mBAqBC,0BAA0B,CAAC,MAAM;;;mBAGjC,0BAA0B,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAqEhB,oBAAoB,GAAG,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA6FhC,sBAAsB,CAAC,YAAY,GAAG,EAAE;;;4BAGnC,sBAAsB,CAAC,KAAK,GAAG,EAAE;;;;;;EAM/D,mBAAmB,CAAC,UAAU,EAAE,MAAM,CAAC;;;;;;EAMvC,mBAAmB,CAAC,iBAAiB,EAAE,MAAM,CAAC;;;;;;;;;;;;;;EAc9C,mBAAmB,CAAC,cAAc,EAAE,MAAM,CAAC;;EAE3C,mBAAmB,CAAC,cAAc,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;EAsB3C,qBAAqB,CAAC,MAAM,CAAC;;EAE7B,mBAAmB,CAAC,eAAe,EAAE,MAAM,CAAC;;;;;EAK5C,mBAAmB,CAAC,kBAAkB,EAAE,MAAM,CAAC;;EAE/C,mBAAmB,CAAC,cAAc,EAAE,MAAM,CAAC;;EAE3C,mBAAmB,CAAC,kBAAkB,EAAE,MAAM,CAAC;;EAE/C,mBAAmB,CAAC,mBAAmB,EAAE,MAAM,CAAC;;EAEhD,mBAAmB,CAAC,kBAAkB,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2FlD;CACA,CAAC,CAAC","sourcesContent":["import { simpleTextureSample, thinFilmTextureSample } from '../../materialTextureSlots.js';\nimport { materialRowsGlsl } from '../../materialLayout.js';\nimport { materialAlphaModeConstants } from '../../../scene/OpenPBRMaterial.js';\nimport { INSTANCE_VEC4_STRIDE } from '../../bvhAccel.js';\nimport { mapAlphaUsageConstants } from '../../materialConstants.js';\n// 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';\n\nexport default createShaderMixin({\n  uniforms: {\n    materialBuffer: Shader.uniform('sampler2D'),\n    materialBufferColumns: Shader.uniform('int', 1),\n    mapInfo: Shader.arrayUniform('vec4', 'NUM_MAPS'),\n    mapTransform: Shader.arrayUniform('vec4', 'NUM_MAPS'),\n    mapUvChannel: Shader.arrayUniform('float', 'NUM_MAPS'),\n    mapColorLinear: Shader.arrayUniform('float', 'NUM_MAPS'),\n    map: Shader.uniform('sampler2DArray')\n  },\n  defines: {\n    NUM_MATERIALS: 1\n  },\n  main: glsl`\n${materialRowsGlsl()}\n#ifdef HAS_GLTF_ANISOTROPY\nvec2 gltf_anisotropy_to_openpbr(float roughness, float strength) {\n  if (strength == 0.0) { return vec2(roughness, 0.0); }\n  float u = roughness * roughness;\n  float a = u + (1.0 - u) * strength * strength;\n  if (a == 0.0) { return vec2(0.0); }\n  return vec2(pow((a*a + u*u) * 0.5, 0.25), clamp(1.0 - u/a, 0.0, 1.0));\n}\n\n#endif\n\nvec3 sRGBToLinear(vec3 c) {\n  return mix(pow(c * 0.9478672986 + 0.0521327014, vec3(2.4)), c * 0.0773993808, vec3(lessThan(c, vec3(0.04045))));\n}\nvec4 fetchMatData(int i) {\n  return fetchData(materialBuffer, i, materialBufferColumns);\n}\n\n// Shared by surface evaluation and shadow occlusion, after texture factors.\nfloat resolveMaterialAlpha(float alpha, int alphaMode, float alphaCutoff) {\n  if (alphaMode == ${materialAlphaModeConstants.opaque}) {\n    return 1.0;\n  }\n  if (alphaMode == ${materialAlphaModeConstants.mask}) {\n    return alpha >= alphaCutoff ? 1.0 : 0.0;\n  }\n  return alpha;\n}\n\nfloat getMatType(int idx) {\n  return fetchMatData(idx * MAT_DATA_SIZE + MAT_ROW_COLOR).w;\n}\n\nvec2 unpackMaterialIndex(int val) {\n  return vec2(float(val >> 8), float(val & 0xff) / 255.0);\n}\n\n#ifdef NUM_MAPS\nvec3 decodeMapColor(int index, vec3 c) {\n  if (mapColorLinear[index] > 0.5) { return c; }\n  return sRGBToLinear(c);\n}\n\nvec2 getMapSize(int index) {\n  return mapInfo[index].xy;\n}\n\nfloat getMapLayer(int index) {\n  return floor(mapInfo[index].z);\n}\n\nvec2 getMapOffset(int index) {\n  return vec2(fract(mapInfo[index].z), mapInfo[index].w);\n}\n\nvec2 getMapUV(int index, vec2 uv) {\n  vec4 transform = mapTransform[index];\n  vec2 repeatedUv = fract(uv * transform.xy + transform.zw);\n  vec2 atlasTexel = 1.0 / vec2(textureSize(map, 0).xy);\n  vec2 firstTexelCenter = getMapOffset(index);\n  vec2 sourceExtent = getMapSize(index) + atlasTexel;\n  vec2 sourceOrigin = firstTexelCenter - 0.5 * atlasTexel;\n  vec2 lastTexelCenter = firstTexelCenter + sourceExtent - atlasTexel;\n  return clamp(\n    sourceOrigin + repeatedUv * sourceExtent,\n    firstTexelCenter,\n    lastTexelCenter\n  );\n}\n\nvec2 getMapUvSet(int index, vec2 uv, vec2 uv1) {\n  return mapUvChannel[index] > 0.5 ? uv1 : uv;\n}\n\nvec4 sampleMap(int index, vec2 uv) {\n  return texture(map, vec3(getMapUV(index, uv), getMapLayer(index)));\n}\n#endif\n\n// OpenPBR 1.1.1: RMS-preserving GGX anisotropy, shared by base and coat.\nvec2 openpbr_roughness_to_alpha(float roughness, float anisotropy) {\n  float alpha = roughness * roughness;\n  float alphaMin = ROUGHNESS_MIN * ROUGHNESS_MIN;\n  if (anisotropy == 0.0) { return vec2(max(alphaMin, alpha)); }\n  float complement = 1.0 - anisotropy;\n  float alphaT = alpha * sqrt(2.0 / (1.0 + complement * complement));\n  return max(vec2(alphaMin), vec2(alphaT, complement * alphaT));\n}\n\nvec4 fetchIns(int i);\nvec3 getInstanceColor(int instanceIndex) {\n  if (instanceIndex < 0) return vec3(1.0);\n  return fetchIns(instanceIndex * ${INSTANCE_VEC4_STRIDE + ''} + 9).rgb;\n}\n\nvoid getMaterial(\n  inout OpenPbrResolvedMaterial mat,\n  int materialIndex,\n  vec2 uv,\n  vec2 uv1,\n  int instanceIndex\n) {\n  int i = materialIndex * MAT_DATA_SIZE;\n  vec4 colorAndMatType = fetchMatData(i + MAT_ROW_COLOR);\n  vec4 roughnessAndNormal = fetchMatData(i + MAT_ROW_ROUGHNESS_NORMAL);\n  vec4 metallicAndMapIndex = fetchMatData(i + MAT_ROW_METALLIC_MAPS);\n  vec4 emissionAndEmissiveMapIndex = fetchMatData(i + MAT_ROW_EMISSION);\n  vec4 iorAndTransmission = fetchMatData(i + MAT_ROW_IOR_TRANSMISSION);\n  vec4 misc = fetchMatData(i + MAT_ROW_MISC);\n  vec4 alphaAndThinFilm = fetchMatData(i + MAT_ROW_ALPHA_FILM);\n  vec4 baseControls = fetchMatData(i + MAT_ROW_BASE_CONTROLS);\n  vec4 specularAndFuzz = fetchMatData(i + MAT_ROW_SPECULAR_FUZZ);\n  vec4 subsurface = fetchMatData(i + MAT_ROW_SUBSURFACE);\n  vec4 fuzz = fetchMatData(i + MAT_ROW_FUZZ);\n  vec4 coat = fetchMatData(i + MAT_ROW_COAT);\n  vec4 coatControls = fetchMatData(i + MAT_ROW_COAT_CONTROLS);\n  vec4 filmAndDispersion = fetchMatData(i + MAT_ROW_FILM_DISPERSION);\n  vec4 standaloneMetalRoughMaps = fetchMatData(i + MAT_ROW_STANDALONE_MAPS);\n  int mapAlphaUsage = int(misc.a);\n\n  mat.baseColor = colorAndMatType.rgb;\n  mat.materialType = int(colorAndMatType.w);\n  mat.specularRoughness = roughnessAndNormal.x;\n  mat.baseMetalness = metallicAndMapIndex.x;\n  mat.specularAnisotropy = clamp(metallicAndMapIndex.y, 0.0, 1.0);\n  mat.emission = emissionAndEmissiveMapIndex.rgb;\n  mat.inside = false;\n  mat.specularIor = iorAndTransmission.x;\n  mat.transmissionWeight = iorAndTransmission.y;\n#ifdef HAS_MEDIUM\n  mat.mediumType = int(iorAndTransmission.z);\n#else\n  mat.mediumType = 0;\n#endif\n  mat.thinWalled = iorAndTransmission.w > 0.5;\n  mat.bevel = misc.r;\n  mat.transmissionDispersionScale = misc.g;\n  mat.dispersionAbbeNumber = max(filmAndDispersion.y, 1e-6);\n  mat.thinFilmThickness = misc.b;\n  mat.thinFilmIor = alphaAndThinFilm.b;\n  mat.thinFilmWeight = clamp(filmAndDispersion.x, 0.0, 1.0);\n  // OpenPBR specifies micrometres; the interference routine uses nanometres.\n  mat.thinFilmThickness *= 1000.0;\n  mat.baseWeight = clamp(baseControls.x, 0.0, 1.0);\n  mat.diffuseRoughness = clamp(baseControls.y, 0.0, 1.0);\n  mat.specularWeight = max(0.0, baseControls.z);\n  mat.subsurfaceWeight = clamp(baseControls.w, 0.0, 1.0);\n  mat.specularColor = max(specularAndFuzz.rgb, vec3(0.0));\n  mat.fuzzWeight = clamp(specularAndFuzz.w, 0.0, 1.0);\n  mat.subsurfaceColor = max(subsurface.rgb, vec3(0.0));\n  mat.transmissionColor = max(fetchMatData(i + MAT_ROW_TRANSMISSION_COLOR).rgb, vec3(0.0));\n  mat.fuzzColor = max(fuzz.rgb, vec3(0.0));\n  mat.fuzzRoughness = clamp(fuzz.w, 0.0, 1.0);\n  mat.coatColor = max(coat.rgb, vec3(0.0));\n  mat.coatWeight = clamp(coat.w, 0.0, 1.0);\n  mat.coatRoughness = clamp(coatControls.x, ROUGHNESS_MIN, 1.0);\n  mat.coatAnisotropy = clamp(coatControls.y, 0.0, 1.0);\n  mat.coatIor = max(coatControls.z, 1.0);\n  mat.coatDarkening = clamp(coatControls.w, 0.0, 1.0);\n\n#ifdef HAS_MEDIUM\n  mat.mediumExtinction = max(fetchMatData(i + MAT_ROW_MEDIUM_EXTINCTION).rgb, vec3(0.0));\n  mat.mediumAnisotropy = clamp(fetchMatData(i + MAT_ROW_MEDIUM_EXTINCTION).a, -1.0, 1.0);\n  mat.mediumScattering = max(fetchMatData(i + MAT_ROW_MEDIUM_SCATTERING).rgb, vec3(0.0));\n  mat.mediumType = max(max(mat.mediumExtinction.x, mat.mediumExtinction.y), mat.mediumExtinction.z) > 0.0 ? 1 : 0;\n#endif\n\n\n#ifdef HAS_ALPHA\n  mat.alpha = alphaAndThinFilm.r;\n#else\n  mat.alpha = 1.0;\n#endif\n\n  #ifdef NUM_DIFFUSE_MAPS\n    int diffuseMapIndex = int(metallicAndMapIndex.z);\n    if (diffuseMapIndex >= 0) {\n      vec4 diffuse = sampleMap(\n        diffuseMapIndex, getMapUvSet(diffuseMapIndex, uv, uv1)\n      );\n      // Material factors from THREE / glTF are already linear. Only color\n      // textures need decoding from their stored sRGB values.\n      mat.baseColor *= decodeMapColor(diffuseMapIndex, diffuse.rgb);\n\n      // Map alpha to transmission\n      if (mapAlphaUsage == ${mapAlphaUsageConstants.transmission + ''}) {\n        mat.transmissionWeight = 1.0 - diffuse.a;\n      }\n      else if (mapAlphaUsage == ${mapAlphaUsageConstants.alpha + ''}) {\n        mat.alpha *= diffuse.a;\n      }\n    }\n  #endif\n\n  ${simpleTextureSample('alphaMap', 'glsl')}\n\n  mat.alpha = resolveMaterialAlpha(\n    mat.alpha, int(fetchMatData(i + MAT_ROW_ALPHA).w), standaloneMetalRoughMaps.w\n  );\n\n  ${simpleTextureSample('transmissionMap', 'glsl')}\n\n  #ifdef NUM_METALLIC_ROUGHNESS_MAPS\n    int metallicRoughnessMapIndex = int(metallicAndMapIndex.w);\n    if (metallicRoughnessMapIndex >= 0) {\n      vec4 metallicRoughness = sampleMap(\n        metallicRoughnessMapIndex,\n        getMapUvSet(metallicRoughnessMapIndex, uv, uv1)\n      );\n      mat.baseMetalness *= metallicRoughness.b;\n      mat.specularRoughness *= metallicRoughness.g;\n    }\n  #endif\n\n  ${simpleTextureSample('roughnessMap', 'glsl')}\n\n  ${simpleTextureSample('metalnessMap', 'glsl')}\n\n  #ifdef NUM_EMISSIVE_MAPS\n    int emissiveMapIndex = int(emissionAndEmissiveMapIndex.w);\n    if (emissiveMapIndex >= 0) {\n      vec3 emissive = sampleMap(\n        emissiveMapIndex, getMapUvSet(emissiveMapIndex, uv, uv1)\n      ).rgb;\n      mat.emission *= decodeMapColor(emissiveMapIndex, emissive);\n    }\n  #endif\n\n  #ifdef NUM_COAT_WEIGHT_MAPS\n    int emissionCoatMapIndex = int(fetchMatData(i + MAT_ROW_LAYER_MAPS).x);\n    if (emissionCoatMapIndex >= 0 && mat.materialType == 0) {\n      float emissionCoatWeight = clamp(coat.w, 0.0, 1.0) * sampleMap(\n        emissionCoatMapIndex, getMapUvSet(emissionCoatMapIndex, uv, uv1)\n      ).r;\n      mat.emission *= mix(vec3(1.0), sqrt(max(coat.rgb, vec3(0.0))), emissionCoatWeight);\n    }\n  #endif\n\n  ${thinFilmTextureSample('glsl')}\n\n  ${simpleTextureSample('coatWeightMap', 'glsl')}\n#ifdef NUM_COAT_NORMAL_MAPS\n  mat.coatNormalEnabled = fetchMatData(i + MAT_ROW_LAYER_MAPS).z >= 0.0 && mat.coatWeight > 0.0;\n#endif\n\n  ${simpleTextureSample('coatRoughnessMap', 'glsl')}\n\n  ${simpleTextureSample('fuzzColorMap', 'glsl')}\n\n  ${simpleTextureSample('fuzzRoughnessMap', 'glsl')}\n\n  ${simpleTextureSample('specularWeightMap', 'glsl')}\n\n  ${simpleTextureSample('specularColorMap', 'glsl')}\n\n  vec4 directionInfo = fetchMatData(i + MAT_ROW_DIRECTION_NORMAL);\n  mat.anisotropyDirection = vec2(1.0, 0.0);\n  mat.anisotropyDirectionEnabled = directionInfo.y != 0.0;\n  mat.coatAnisotropyRotation = fetchMatData(i + MAT_ROW_FILM_TEXTURE).x;\n#ifdef NUM_ANISOTROPY_MAPS\n  if (directionInfo.x >= 0.0) {\n    int index = int(directionInfo.x);\n    vec4 texel = sampleMap(index, getMapUvSet(index, uv, uv1));\n    mat.specularAnisotropy *= texel.b;\n    vec2 direction = texel.rg * 2.0 - 1.0;\n    if (dot(direction, direction) > 1e-4) mat.anisotropyDirection = normalize(direction);\n    mat.anisotropyDirectionEnabled = true;\n  }\n#endif\n#ifdef HAS_GLTF_ANISOTROPY\n  if (fetchMatData(i + MAT_ROW_FILM_TEXTURE).y > 0.5 && mat.specularAnisotropy > 0.0) {\n    vec2 native = gltf_anisotropy_to_openpbr(clamp(mat.specularRoughness, 0.0, 1.0), mat.specularAnisotropy);\n    mat.specularRoughness = native.x;\n    mat.specularAnisotropy = native.y;\n  }\n#endif\n  if (mat.anisotropyDirectionEnabled) {\n    float theta = directionInfo.y;\n    vec2 d = mat.anisotropyDirection;\n    mat.anisotropyDirection = vec2(cos(theta)*d.x - sin(theta)*d.y, sin(theta)*d.x + cos(theta)*d.y);\n  }\n\n  // OpenPBR 1.1.1: coat refraction broadens all base microfacet lobes.\n  // Keep the zero-coat / smooth-coat paths byte-identical.\n  if (mat.coatWeight > 0.0 && mat.coatRoughness > 0.0) {\n    float baseRoughness2 = mat.specularRoughness * mat.specularRoughness;\n    float coatRoughness2 = mat.coatRoughness * mat.coatRoughness;\n    mat.specularRoughness = mix(mat.specularRoughness,\n      pow(min(1.0, baseRoughness2 * baseRoughness2 + 2.0 * coatRoughness2 * coatRoughness2), 0.25), mat.coatWeight);\n  }\n  vec3 instanceColor = getInstanceColor(instanceIndex);\n  mat.baseColor *= instanceColor;\n  if (mat.materialType == UNLIT) mat.emission *= instanceColor;\n\n  mat.specularRoughness = clamp(mat.specularRoughness, ROUGHNESS_MIN, 1.0);\n  mat.baseMetalness = clamp(mat.baseMetalness, 0.0, 1.0);\n  vec2 specularAlpha = openpbr_roughness_to_alpha(mat.specularRoughness, mat.specularAnisotropy);\n  mat.alphaX = specularAlpha.x;\n  mat.alphaY = specularAlpha.y;\n}\n\n#if defined(NUM_NORMAL_MAPS)\nvec3 getMatNormal(int materialIndex, vec2 uv, vec3 normal, vec3 dp1, vec3 dp2, vec2 duv1, vec2 duv2) {\n  int i = materialIndex * MAT_DATA_SIZE;\n  vec4 roughnessAndNormal = fetchMatData(i + MAT_ROW_ROUGHNESS_NORMAL);\n  int normalMapIndex = int(roughnessAndNormal.y);\n  if (normalMapIndex >= 0) {\n    // http://www.thetenthplanet.de/archives/1180\n    // TODO use tangent attribute\n    // Compute co-tangent and co-bitangent vectors\n    vec3 dp2perp = cross(dp2, normal);\n    vec3 dp1perp = cross(normal, dp1);\n    vec3 dpdu = dp2perp * duv1.x + dp1perp * duv2.x;\n    vec3 dpdv = dp2perp * duv1.y + dp1perp * duv2.y;\n    float gradientLengthSquared = max(dot(dpdu, dpdu), dot(dpdv, dpdv));\n    if (gradientLengthSquared > 1e-12) {\n      float invmax = inversesqrt(gradientLengthSquared);\n      dpdu *= invmax;\n      dpdv *= invmax;\n    }\n    else {\n      // Imported meshes can legitimately omit UVs and use generated or\n      // triplanar projection. Their zero UV derivatives must not turn the TBN\n      // basis (and then every lighting result) into NaN.\n      vec3 referenceAxis = abs(normal.z) < 0.999\n        ? vec3(0.0, 0.0, 1.0)\n        : vec3(0.0, 1.0, 0.0);\n      dpdu = normalize(cross(referenceAxis, normal));\n      dpdv = cross(normal, dpdu);\n    }\n\n    vec3 n = 2.0 * sampleMap(normalMapIndex, uv).rgb - 1.0;\n    n.xy *= roughnessAndNormal.zw;\n    n = normalize(n);\n\n    mat3 tbn = mat3(dpdu, dpdv, normal);\n\n    return normalize(tbn * n);\n  } else {\n    return normal;\n  }\n}\n#endif\n\n`\n});\n"]}
+{"version":3,"file":"materialBuffer.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/materialBuffer.glsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAC3F,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAElE,eAAe,iBAAiB,CAAC;IAC/B,QAAQ,EAAE;QACR,cAAc,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QAC3C,qBAAqB,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;QAC/C,OAAO,EAAE,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,UAAU,CAAC;QAChD,YAAY,EAAE,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,UAAU,CAAC;QACrD,YAAY,EAAE,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,UAAU,CAAC;QACtD,cAAc,EAAE,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,UAAU,CAAC;QACxD,OAAO,EAAE,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,UAAU,CAAC;QAChD,GAAG,EAAE,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC;KACtC;IACD,OAAO,EAAE;QACP,aAAa,EAAE,CAAC;KACjB;IACD,IAAI,EAAE,IAAI,CAAA;EACV,gBAAgB,EAAE;;;;;;;;;;;;;;;;;;;;;mBAqBC,0BAA0B,CAAC,MAAM;;;mBAGjC,0BAA0B,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAmGhB,oBAAoB,GAAG,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA8FhC,sBAAsB,CAAC,YAAY,GAAG,EAAE;;;4BAGnC,sBAAsB,CAAC,KAAK,GAAG,EAAE;;;;;;EAM/D,mBAAmB,CAAC,UAAU,EAAE,MAAM,CAAC;;;;;;EAMvC,mBAAmB,CAAC,iBAAiB,EAAE,MAAM,CAAC;;;;;;;;;;;;;;EAc9C,mBAAmB,CAAC,cAAc,EAAE,MAAM,CAAC;;EAE3C,mBAAmB,CAAC,cAAc,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;EAsB3C,qBAAqB,CAAC,MAAM,CAAC;;EAE7B,mBAAmB,CAAC,eAAe,EAAE,MAAM,CAAC;;;;;;EAM5C,mBAAmB,CAAC,kBAAkB,EAAE,MAAM,CAAC;;EAE/C,mBAAmB,CAAC,cAAc,EAAE,MAAM,CAAC;;EAE3C,mBAAmB,CAAC,kBAAkB,EAAE,MAAM,CAAC;;EAE/C,mBAAmB,CAAC,mBAAmB,EAAE,MAAM,CAAC;;EAEhD,mBAAmB,CAAC,kBAAkB,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2FlD;CACA,CAAC,CAAC","sourcesContent":["import { simpleTextureSample, thinFilmTextureSample } from '../../materialTextureSlots.js';\nimport { materialRowsGlsl } from '../../materialLayout.js';\nimport { materialAlphaModeConstants } from '../../../scene/OpenPBRMaterial.js';\nimport { INSTANCE_VEC4_STRIDE } from '../../bvhAccel.js';\nimport { mapAlphaUsageConstants } from '../../materialConstants.js';\n// 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';\n\nexport default createShaderMixin({\n  uniforms: {\n    materialBuffer: Shader.uniform('sampler2D'),\n    materialBufferColumns: Shader.uniform('int', 1),\n    mapInfo: Shader.arrayUniform('vec4', 'NUM_MAPS'),\n    mapTransform: Shader.arrayUniform('vec4', 'NUM_MAPS'),\n    mapUvChannel: Shader.arrayUniform('float', 'NUM_MAPS'),\n    mapColorLinear: Shader.arrayUniform('float', 'NUM_MAPS'),\n    mapWrap: Shader.arrayUniform('vec2', 'NUM_MAPS'),\n    map: Shader.uniform('sampler2DArray')\n  },\n  defines: {\n    NUM_MATERIALS: 1\n  },\n  main: glsl`\n${materialRowsGlsl()}\n#ifdef HAS_GLTF_ANISOTROPY\nvec2 gltf_anisotropy_to_openpbr(float roughness, float strength) {\n  if (strength == 0.0) { return vec2(roughness, 0.0); }\n  float u = roughness * roughness;\n  float a = u + (1.0 - u) * strength * strength;\n  if (a == 0.0) { return vec2(0.0); }\n  return vec2(pow((a*a + u*u) * 0.5, 0.25), clamp(1.0 - u/a, 0.0, 1.0));\n}\n\n#endif\n\nvec3 sRGBToLinear(vec3 c) {\n  return mix(pow(c * 0.9478672986 + 0.0521327014, vec3(2.4)), c * 0.0773993808, vec3(lessThan(c, vec3(0.04045))));\n}\nvec4 fetchMatData(int i) {\n  return fetchData(materialBuffer, i, materialBufferColumns);\n}\n\n// Shared by surface evaluation and shadow occlusion, after texture factors.\nfloat resolveMaterialAlpha(float alpha, int alphaMode, float alphaCutoff) {\n  if (alphaMode == ${materialAlphaModeConstants.opaque}) {\n    return 1.0;\n  }\n  if (alphaMode == ${materialAlphaModeConstants.mask}) {\n    return alpha >= alphaCutoff ? 1.0 : 0.0;\n  }\n  return alpha;\n}\n\nfloat getMatType(int idx) {\n  return fetchMatData(idx * MAT_DATA_SIZE + MAT_ROW_COLOR).w;\n}\n\nvec2 unpackMaterialIndex(int val) {\n  return vec2(float(val >> 8), float(val & 0xff) / 255.0);\n}\n\n#ifdef NUM_MAPS\nvec3 decodeMapColor(int index, vec3 c) {\n  if (mapColorLinear[index] > 0.5) { return c; }\n  return sRGBToLinear(c);\n}\n\nvec2 getMapSize(int index) {\n  return mapInfo[index].xy;\n}\n\nfloat getMapLayer(int index) {\n  return floor(mapInfo[index].z);\n}\n\nvec2 getMapOffset(int index) {\n  return vec2(fract(mapInfo[index].z), mapInfo[index].w);\n}\n\nfloat wrapMapCoordinate(float value, float mode) {\n  if (mode < 0.5) return fract(value);\n  if (mode < 1.5) return clamp(value, 0.0, 1.0);\n  return 1.0 - abs(1.0 - (value - 2.0 * floor(value * 0.5)));\n}\n\nvec2 wrappedMapUv(int index, vec2 uv) {\n  vec4 transform = mapTransform[index];\n  vec2 value = uv * transform.xy + transform.zw;\n  return vec2(wrapMapCoordinate(value.x, mapWrap[index].x), wrapMapCoordinate(value.y, mapWrap[index].y));\n}\n\nvec2 getMapUV(int index, vec2 uv) {\n  vec2 repeatedUv = wrappedMapUv(index, uv);\n  vec2 atlasTexel = 1.0 / vec2(textureSize(map, 0).xy);\n  vec2 firstTexelCenter = getMapOffset(index);\n  vec2 sourceExtent = getMapSize(index) + atlasTexel;\n  vec2 sourceOrigin = firstTexelCenter - 0.5 * atlasTexel;\n  vec2 lastTexelCenter = firstTexelCenter + sourceExtent - atlasTexel;\n  return clamp(\n    sourceOrigin + repeatedUv * sourceExtent,\n    firstTexelCenter,\n    lastTexelCenter\n  );\n}\n\nvec2 getMapUvSet(int index, vec2 uv, vec2 uv1) {\n  return mapUvChannel[index] > 0.5 ? uv1 : uv;\n}\n\nvec4 loadMapTexel(int index, ivec2 coordinate, ivec2 size, ivec2 origin, vec2 modes) {\n  ivec2 p = clamp(coordinate, ivec2(0), size - 1);\n  if (modes.x < 0.5) p.x = ((coordinate.x % size.x) + size.x) % size.x;\n  if (modes.y < 0.5) p.y = ((coordinate.y % size.y) + size.y) % size.y;\n  return texelFetch(map, ivec3(origin + p, int(getMapLayer(index))), 0);\n}\n\nvec4 sampleMap(int index, vec2 uv) {\n  ivec2 size = ivec2(round(getMapSize(index) * vec2(textureSize(map, 0).xy) + 1.0));\n  vec2 texel = wrappedMapUv(index, uv) * vec2(size) - 0.5;\n  vec2 modes = mapWrap[index];\n  if ((size.x > 1 && modes.x < 0.5 && (texel.x < 0.0 || texel.x > float(size.x - 1))) ||\n      (size.y > 1 && modes.y < 0.5 && (texel.y < 0.0 || texel.y > float(size.y - 1)))) {\n    ivec2 base = ivec2(floor(texel));\n    vec2 weight = fract(texel);\n    ivec2 origin = ivec2(round(getMapOffset(index) * vec2(textureSize(map, 0).xy) - 0.5));\n    return mix(\n      mix(loadMapTexel(index, base, size, origin, modes), loadMapTexel(index, base + ivec2(1, 0), size, origin, modes), weight.x),\n      mix(loadMapTexel(index, base + ivec2(0, 1), size, origin, modes), loadMapTexel(index, base + ivec2(1, 1), size, origin, modes), weight.x), weight.y);\n  }\n  return texture(map, vec3(getMapUV(index, uv), getMapLayer(index)));\n}\n#endif\n\n// OpenPBR 1.1.1: RMS-preserving GGX anisotropy, shared by base and coat.\nvec2 openpbr_roughness_to_alpha(float roughness, float anisotropy) {\n  float alpha = roughness * roughness;\n  float alphaMin = ROUGHNESS_MIN * ROUGHNESS_MIN;\n  if (anisotropy == 0.0) { return vec2(max(alphaMin, alpha)); }\n  float complement = 1.0 - anisotropy;\n  float alphaT = alpha * sqrt(2.0 / (1.0 + complement * complement));\n  return max(vec2(alphaMin), vec2(alphaT, complement * alphaT));\n}\n\nvec4 fetchIns(int i);\nvec3 getInstanceColor(int instanceIndex) {\n  if (instanceIndex < 0) return vec3(1.0);\n  return fetchIns(instanceIndex * ${INSTANCE_VEC4_STRIDE + ''} + 9).rgb;\n}\n\nvoid getMaterial(\n  inout OpenPbrResolvedMaterial mat,\n  int materialIndex,\n  vec2 uv,\n  vec2 uv1,\n  int instanceIndex,\n  vec3 vertexColor\n) {\n  int i = materialIndex * MAT_DATA_SIZE;\n  vec4 colorAndMatType = fetchMatData(i + MAT_ROW_COLOR);\n  vec4 roughnessAndNormal = fetchMatData(i + MAT_ROW_ROUGHNESS_NORMAL);\n  vec4 metallicAndMapIndex = fetchMatData(i + MAT_ROW_METALLIC_MAPS);\n  vec4 emissionAndEmissiveMapIndex = fetchMatData(i + MAT_ROW_EMISSION);\n  vec4 iorAndTransmission = fetchMatData(i + MAT_ROW_IOR_TRANSMISSION);\n  vec4 misc = fetchMatData(i + MAT_ROW_MISC);\n  vec4 alphaAndThinFilm = fetchMatData(i + MAT_ROW_ALPHA_FILM);\n  vec4 baseControls = fetchMatData(i + MAT_ROW_BASE_CONTROLS);\n  vec4 specularAndFuzz = fetchMatData(i + MAT_ROW_SPECULAR_FUZZ);\n  vec4 subsurface = fetchMatData(i + MAT_ROW_SUBSURFACE);\n  vec4 fuzz = fetchMatData(i + MAT_ROW_FUZZ);\n  vec4 coat = fetchMatData(i + MAT_ROW_COAT);\n  vec4 coatControls = fetchMatData(i + MAT_ROW_COAT_CONTROLS);\n  vec4 filmAndDispersion = fetchMatData(i + MAT_ROW_FILM_DISPERSION);\n  vec4 standaloneMetalRoughMaps = fetchMatData(i + MAT_ROW_STANDALONE_MAPS);\n  int mapAlphaUsage = int(misc.a);\n\n  mat.baseColor = colorAndMatType.rgb;\n  mat.materialType = int(colorAndMatType.w);\n  mat.specularRoughness = roughnessAndNormal.x;\n  mat.baseMetalness = metallicAndMapIndex.x;\n  mat.specularAnisotropy = clamp(metallicAndMapIndex.y, 0.0, 1.0);\n  mat.emission = emissionAndEmissiveMapIndex.rgb;\n  mat.inside = false;\n  mat.specularIor = iorAndTransmission.x;\n  mat.transmissionWeight = iorAndTransmission.y;\n#ifdef HAS_MEDIUM\n  mat.mediumType = int(iorAndTransmission.z);\n#else\n  mat.mediumType = 0;\n#endif\n  mat.thinWalled = iorAndTransmission.w > 0.5;\n  mat.bevel = misc.r;\n  mat.transmissionDispersionScale = misc.g;\n  mat.dispersionAbbeNumber = max(filmAndDispersion.y, 1e-6);\n  mat.thinFilmThickness = misc.b;\n  mat.thinFilmIor = alphaAndThinFilm.b;\n  mat.thinFilmWeight = clamp(filmAndDispersion.x, 0.0, 1.0);\n  // OpenPBR specifies micrometres; the interference routine uses nanometres.\n  mat.thinFilmThickness *= 1000.0;\n  mat.baseWeight = clamp(baseControls.x, 0.0, 1.0);\n  mat.diffuseRoughness = clamp(baseControls.y, 0.0, 1.0);\n  mat.specularWeight = max(0.0, baseControls.z);\n  mat.subsurfaceWeight = clamp(baseControls.w, 0.0, 1.0);\n  mat.specularColor = max(specularAndFuzz.rgb, vec3(0.0));\n  mat.fuzzWeight = clamp(specularAndFuzz.w, 0.0, 1.0);\n  mat.subsurfaceColor = max(subsurface.rgb, vec3(0.0));\n  mat.transmissionColor = max(fetchMatData(i + MAT_ROW_TRANSMISSION_COLOR).rgb, vec3(0.0));\n  mat.fuzzColor = max(fuzz.rgb, vec3(0.0));\n  mat.fuzzRoughness = clamp(fuzz.w, 0.0, 1.0);\n  mat.coatColor = max(coat.rgb, vec3(0.0));\n  mat.coatWeight = clamp(coat.w, 0.0, 1.0);\n  mat.coatRoughness = clamp(coatControls.x, ROUGHNESS_MIN, 1.0);\n  mat.coatAnisotropy = clamp(coatControls.y, 0.0, 1.0);\n  mat.coatIor = max(coatControls.z, 1.0);\n  mat.coatDarkening = clamp(coatControls.w, 0.0, 1.0);\n\n#ifdef HAS_MEDIUM\n  mat.mediumExtinction = max(fetchMatData(i + MAT_ROW_MEDIUM_EXTINCTION).rgb, vec3(0.0));\n  mat.mediumAnisotropy = clamp(fetchMatData(i + MAT_ROW_MEDIUM_EXTINCTION).a, -1.0, 1.0);\n  mat.mediumScattering = max(fetchMatData(i + MAT_ROW_MEDIUM_SCATTERING).rgb, vec3(0.0));\n  mat.mediumType = max(max(mat.mediumExtinction.x, mat.mediumExtinction.y), mat.mediumExtinction.z) > 0.0 ? 1 : 0;\n#endif\n\n\n#ifdef HAS_ALPHA\n  mat.alpha = alphaAndThinFilm.r;\n#else\n  mat.alpha = 1.0;\n#endif\n\n  #ifdef NUM_DIFFUSE_MAPS\n    int diffuseMapIndex = int(metallicAndMapIndex.z);\n    if (diffuseMapIndex >= 0) {\n      vec4 diffuse = sampleMap(\n        diffuseMapIndex, getMapUvSet(diffuseMapIndex, uv, uv1)\n      );\n      // Material factors from THREE / glTF are already linear. Only color\n      // textures need decoding from their stored sRGB values.\n      mat.baseColor *= decodeMapColor(diffuseMapIndex, diffuse.rgb);\n\n      // Map alpha to transmission\n      if (mapAlphaUsage == ${mapAlphaUsageConstants.transmission + ''}) {\n        mat.transmissionWeight = 1.0 - diffuse.a;\n      }\n      else if (mapAlphaUsage == ${mapAlphaUsageConstants.alpha + ''}) {\n        mat.alpha *= diffuse.a;\n      }\n    }\n  #endif\n\n  ${simpleTextureSample('alphaMap', 'glsl')}\n\n  mat.alpha = resolveMaterialAlpha(\n    mat.alpha, int(fetchMatData(i + MAT_ROW_ALPHA).w), standaloneMetalRoughMaps.w\n  );\n\n  ${simpleTextureSample('transmissionMap', 'glsl')}\n\n  #ifdef NUM_METALLIC_ROUGHNESS_MAPS\n    int metallicRoughnessMapIndex = int(metallicAndMapIndex.w);\n    if (metallicRoughnessMapIndex >= 0) {\n      vec4 metallicRoughness = sampleMap(\n        metallicRoughnessMapIndex,\n        getMapUvSet(metallicRoughnessMapIndex, uv, uv1)\n      );\n      mat.baseMetalness *= metallicRoughness.b;\n      mat.specularRoughness *= metallicRoughness.g;\n    }\n  #endif\n\n  ${simpleTextureSample('roughnessMap', 'glsl')}\n\n  ${simpleTextureSample('metalnessMap', 'glsl')}\n\n  #ifdef NUM_EMISSIVE_MAPS\n    int emissiveMapIndex = int(emissionAndEmissiveMapIndex.w);\n    if (emissiveMapIndex >= 0) {\n      vec3 emissive = sampleMap(\n        emissiveMapIndex, getMapUvSet(emissiveMapIndex, uv, uv1)\n      ).rgb;\n      mat.emission *= decodeMapColor(emissiveMapIndex, emissive);\n    }\n  #endif\n\n  #ifdef NUM_COAT_WEIGHT_MAPS\n    int emissionCoatMapIndex = int(fetchMatData(i + MAT_ROW_LAYER_MAPS).x);\n    if (emissionCoatMapIndex >= 0 && mat.materialType == 0) {\n      float emissionCoatWeight = clamp(coat.w, 0.0, 1.0) * sampleMap(\n        emissionCoatMapIndex, getMapUvSet(emissionCoatMapIndex, uv, uv1)\n      ).r;\n      mat.emission *= mix(vec3(1.0), sqrt(max(coat.rgb, vec3(0.0))), emissionCoatWeight);\n    }\n  #endif\n\n  ${thinFilmTextureSample('glsl')}\n\n  ${simpleTextureSample('coatWeightMap', 'glsl')}\n#ifdef USE_COAT_NORMAL_FRAMES\n  // Independent coat shading also applies when the coat has no normal map.\n  mat.coatNormalEnabled = mat.coatWeight > 0.0 && (roughnessAndNormal.y >= 0.0 || fetchMatData(i + MAT_ROW_LAYER_MAPS).z >= 0.0);\n#endif\n\n  ${simpleTextureSample('coatRoughnessMap', 'glsl')}\n\n  ${simpleTextureSample('fuzzColorMap', 'glsl')}\n\n  ${simpleTextureSample('fuzzRoughnessMap', 'glsl')}\n\n  ${simpleTextureSample('specularWeightMap', 'glsl')}\n\n  ${simpleTextureSample('specularColorMap', 'glsl')}\n\n  vec4 directionInfo = fetchMatData(i + MAT_ROW_DIRECTION_NORMAL);\n  mat.anisotropyDirection = vec2(1.0, 0.0);\n  mat.anisotropyDirectionEnabled = directionInfo.y != 0.0;\n  mat.coatAnisotropyRotation = fetchMatData(i + MAT_ROW_FILM_TEXTURE).x;\n#ifdef NUM_ANISOTROPY_MAPS\n  if (directionInfo.x >= 0.0) {\n    int index = int(directionInfo.x);\n    vec4 texel = sampleMap(index, getMapUvSet(index, uv, uv1));\n    mat.specularAnisotropy *= texel.b;\n    vec2 direction = texel.rg * 2.0 - 1.0;\n    if (dot(direction, direction) > 1e-4) mat.anisotropyDirection = normalize(direction);\n    mat.anisotropyDirectionEnabled = true;\n  }\n#endif\n#ifdef HAS_GLTF_ANISOTROPY\n  if (fetchMatData(i + MAT_ROW_FILM_TEXTURE).y > 0.5 && mat.specularAnisotropy > 0.0) {\n    vec2 native = gltf_anisotropy_to_openpbr(clamp(mat.specularRoughness, 0.0, 1.0), mat.specularAnisotropy);\n    mat.specularRoughness = native.x;\n    mat.specularAnisotropy = native.y;\n  }\n#endif\n  if (mat.anisotropyDirectionEnabled) {\n    float theta = directionInfo.y;\n    vec2 d = mat.anisotropyDirection;\n    mat.anisotropyDirection = vec2(cos(theta)*d.x - sin(theta)*d.y, sin(theta)*d.x + cos(theta)*d.y);\n  }\n\n  // OpenPBR 1.1.1: coat refraction broadens all base microfacet lobes.\n  // Keep the zero-coat / smooth-coat paths byte-identical.\n  if (mat.coatWeight > 0.0 && mat.coatRoughness > 0.0) {\n    float baseRoughness2 = mat.specularRoughness * mat.specularRoughness;\n    float coatRoughness2 = mat.coatRoughness * mat.coatRoughness;\n    mat.specularRoughness = mix(mat.specularRoughness,\n      pow(min(1.0, baseRoughness2 * baseRoughness2 + 2.0 * coatRoughness2 * coatRoughness2), 0.25), mat.coatWeight);\n  }\n  vec3 color = getInstanceColor(instanceIndex) * vertexColor;\n  mat.baseColor *= color;\n  if (mat.materialType == UNLIT) mat.emission *= color;\n\n  mat.specularRoughness = clamp(mat.specularRoughness, ROUGHNESS_MIN, 1.0);\n  mat.baseMetalness = clamp(mat.baseMetalness, 0.0, 1.0);\n  vec2 specularAlpha = openpbr_roughness_to_alpha(mat.specularRoughness, mat.specularAnisotropy);\n  mat.alphaX = specularAlpha.x;\n  mat.alphaY = specularAlpha.y;\n}\n\n#if defined(NUM_NORMAL_MAPS)\nvec3 getMatNormal(int materialIndex, vec2 uv, vec3 normal, vec3 dp1, vec3 dp2, vec2 duv1, vec2 duv2) {\n  int i = materialIndex * MAT_DATA_SIZE;\n  vec4 roughnessAndNormal = fetchMatData(i + MAT_ROW_ROUGHNESS_NORMAL);\n  int normalMapIndex = int(roughnessAndNormal.y);\n  if (normalMapIndex >= 0) {\n    // http://www.thetenthplanet.de/archives/1180\n    // TODO use tangent attribute\n    // Compute co-tangent and co-bitangent vectors\n    vec3 dp2perp = cross(dp2, normal);\n    vec3 dp1perp = cross(normal, dp1);\n    vec3 dpdu = dp2perp * duv1.x + dp1perp * duv2.x;\n    vec3 dpdv = dp2perp * duv1.y + dp1perp * duv2.y;\n    float gradientLengthSquared = max(dot(dpdu, dpdu), dot(dpdv, dpdv));\n    if (gradientLengthSquared > 1e-12) {\n      float invmax = inversesqrt(gradientLengthSquared);\n      dpdu *= invmax;\n      dpdv *= invmax;\n    }\n    else {\n      // Imported meshes can legitimately omit UVs and use generated or\n      // triplanar projection. Their zero UV derivatives must not turn the TBN\n      // basis (and then every lighting result) into NaN.\n      vec3 referenceAxis = abs(normal.z) < 0.999\n        ? vec3(0.0, 0.0, 1.0)\n        : vec3(0.0, 1.0, 0.0);\n      dpdu = normalize(cross(referenceAxis, normal));\n      dpdv = cross(normal, dpdu);\n    }\n\n    vec3 n = 2.0 * sampleMap(normalMapIndex, uv).rgb - 1.0;\n    n.xy *= roughnessAndNormal.zw;\n    n = normalize(n);\n\n    mat3 tbn = mat3(dpdu, dpdv, normal);\n\n    return normalize(tbn * n);\n  } else {\n    return normal;\n  }\n}\n#endif\n\n`\n});\n"]}