@meimu/mutracer 0.1.5 → 0.2.0

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

@@ -1,6 +1,6 @@
 import { simpleTextureSample, thinFilmTextureSample } from '../../materialTextureSlots.js';
-import { materialRowsGlsl } from '../../materialLayout.js';
-import { materialAlphaModeConstants } from '../../../scene/OpenPBRMaterial.js';
+import { materialRowsGlsl } from '../../materialLayoutSchema.js';
+import { materialAlphaModeConstants } from '../../materialConstants.js';
 import { INSTANCE_VEC4_STRIDE } from '../../bvhAccel.js';
 import { mapAlphaUsageConstants } from '../../materialConstants.js';
 // Portions adapted from ray-tracing-renderer@0.10.15
@@ -24,7 +24,7 @@ export default createShaderMixin({
     main: glsl `
 ${materialRowsGlsl()}
 #ifdef HAS_GLTF_ANISOTROPY
-vec2 fe(float roughness, float strength) {
+vec2 fv(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;
@@ -34,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 oJ(vec3 c) {
+vec3 mG(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 kG(materialBuffer, i, materialBufferColumns);
+return lm(materialBuffer, i, materialBufferColumns);
 }
 
 
-float lr(float alpha, int alphaMode, float alphaCutoff) {
+float mb(float alpha, int alphaMode, float alphaCutoff) {
 if (alphaMode == ${materialAlphaModeConstants.opaque}) {
 return 1.0;
 }
@@ -52,55 +52,55 @@ return alpha >= alphaCutoff ? 1.0 : 0.0;
 return alpha;
 }
 
-float wb(int idx) {
+float xS(int idx) {
 return fetchMatData(idx * MAT_DATA_SIZE + MAT_ROW_COLOR).w;
 }
 
-vec2 ae(int val) {
+vec2 ah(int val) {
 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 oJ(c);
+return mG(c);
 }
 
-vec2 kJ(int index) {
+vec2 jO(int index) {
 return mapInfo[index].xy;
 }
 
-float lk(int index) {
+float lT(int index) {
 return floor(mapInfo[index].z);
 }
 
-vec2 jP(int index) {
+vec2 kt(int index) {
 return vec2(fract(mapInfo[index].z), mapInfo[index].w);
 }
 
-float fT(float value, float mode) {
+float gg(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) {
+vec2 kZ(int index, vec2 uv) {
 vec4 transform = mapTransform[index];
 vec2 value = uv * transform.xy + transform.zw;
-return vec2(fT(value.x, mapWrap[index].x), fT(value.y, mapWrap[index].y));
+return vec2(gg(value.x, mapWrap[index].x), gg(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;
+vec2 tJ(int index, vec2 uv) {
+vec2 rN = kZ(index, uv);
+vec2 jH = 1.0 / vec2(textureSize(map, 0).xy);
+vec2 eo = kt(index);
+vec2 kS = jO(index) + jH;
+vec2 pJ = eo - 0.5 * jH;
+vec2 ml = eo + kS - jH;
 return clamp(
-oM + qH * kn,
-dZ,
-lD
+pJ + rN * kS,
+eo,
+ml
 );
 }
 
@@ -108,48 +108,48 @@ 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 fe(int index, ivec2 jJ, ivec2 size, ivec2 origin, vec2 modes) {
+ivec2 p = clamp(jJ, ivec2(0), size - 1);
+if (modes.x < 0.5) p.x = ((jJ.x % size.x) + size.x) % size.x;
+if (modes.y < 0.5) p.y = ((jJ.y % size.y) + size.y) % size.y;
+return texelFetch(map, ivec3(origin + p, int(lT(index))), 0);
 }
 
 vec4 sampleMap(int index, vec2 uv) {
-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));
+ivec2 size = ivec2(round(jO(index) * vec2(textureSize(map, 0).xy) + 1.0));
+vec2 dk = kZ(index, uv) * vec2(size) - 0.5;
+vec2 modes = mapWrap[index];
+if ((size.x > 1 && modes.x < 0.5 && (dk.x < 0.0 || dk.x > float(size.x - 1))) ||
+(size.y > 1 && modes.y < 0.5 && (dk.y < 0.0 || dk.y > float(size.y - 1)))) {
+ivec2 base = ivec2(floor(dk));
+vec2 weight = fract(dk);
+ivec2 origin = ivec2(round(kt(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);
+mix(fe(index, base, size, origin, modes), fe(index, base + ivec2(1, 0), size, origin, modes), weight.x),
+mix(fe(index, base + ivec2(0, 1), size, origin, modes), fe(index, base + ivec2(1, 1), size, origin, modes), weight.x), weight.y);
 }
-return texture(map, vec3(sq(index, uv), lk(index)));
+return texture(map, vec3(tJ(index, uv), lT(index)));
 }
 #endif
 
 
-vec2 aK(float roughness, float anisotropy) {
+vec2 aN(float roughness, float anisotropy) {
 float alpha = roughness * roughness;
-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));
+float qe = ROUGHNESS_MIN * ROUGHNESS_MIN;
+if (anisotropy == 0.0) { return vec2(max(qe, alpha)); }
+float dw = 1.0 - anisotropy;
+float tp = alpha * sqrt(2.0 / (1.0 + dw * dw));
+return max(vec2(qe), vec2(tp, dw * tp));
 }
 
-vec4 bv(int i);
-vec3 kI(int instanceIndex) {
+vec4 bF(int i);
+vec3 lp(int instanceIndex) {
 if (instanceIndex < 0) return vec3(1.0);
-return bv(instanceIndex * ${INSTANCE_VEC4_STRIDE + ''} + 9).rgb;
+return bF(instanceIndex * ${INSTANCE_VEC4_STRIDE + ''} + 9).rgb;
 }
 
-void eX(
-inout J mat,
+void dg(
+inout OpenPbrResolvedMaterial mat,
 int materialIndex,
 vec2 uv,
 vec2 uv1,
@@ -157,62 +157,62 @@ int instanceIndex,
 vec3 vertexColor
 ) {
 int i = materialIndex * MAT_DATA_SIZE;
-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 pR = fetchMatData(i + MAT_ROW_COLOR);
+vec4 fG = fetchMatData(i + MAT_ROW_ROUGHNESS_NORMAL);
+vec4 gE = fetchMatData(i + MAT_ROW_METALLIC_MAPS);
+vec4 hY = fetchMatData(i + MAT_ROW_EMISSION);
+vec4 hm = fetchMatData(i + MAT_ROW_IOR_TRANSMISSION);
 vec4 misc = fetchMatData(i + MAT_ROW_MISC);
-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 ov = fetchMatData(i + MAT_ROW_ALPHA_FILM);
+vec4 mB = fetchMatData(i + MAT_ROW_BASE_CONTROLS);
+vec4 pV = fetchMatData(i + MAT_ROW_SPECULAR_FUZZ);
 vec4 subsurface = fetchMatData(i + MAT_ROW_SUBSURFACE);
-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);
+vec4 yj = fetchMatData(i + MAT_ROW_FUZZ);
+vec4 xr = fetchMatData(i + MAT_ROW_COAT);
+vec4 mC = fetchMatData(i + MAT_ROW_COAT_CONTROLS);
+vec4 nV = fetchMatData(i + MAT_ROW_FILM_DISPERSION);
+vec4 ou = fetchMatData(i + MAT_ROW_STANDALONE_MAPS);
 int mapAlphaUsage = int(misc.a);
 
-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.baseColor = pR.rgb;
+mat.materialType = int(pR.w);
+mat.specularRoughness = fG.x;
+mat.baseMetalness = gE.x;
+mat.specularAnisotropy = clamp(gE.y, 0.0, 1.0);
+mat.emission = hY.rgb;
 mat.inside = false;
-mat.specularIor = gZ.x;
-mat.transmissionWeight = gZ.y;
+mat.specularIor = hm.x;
+mat.transmissionWeight = hm.y;
 #ifdef HAS_MEDIUM
-mat.mediumType = int(gZ.z);
+mat.mediumType = int(hm.z);
 #else
 mat.mediumType = 0;
 #endif
-mat.thinWalled = gZ.w > 0.5;
+mat.thinWalled = hm.w > 0.5;
 mat.bevel = misc.r;
 mat.transmissionDispersionScale = misc.g;
-mat.dispersionAbbeNumber = max(mX.y, 1e-6);
+mat.dispersionAbbeNumber = max(nV.y, 1e-6);
 mat.thinFilmThickness = misc.b;
-mat.thinFilmIor = nB.b;
-mat.thinFilmWeight = clamp(mX.x, 0.0, 1.0);
+mat.thinFilmIor = ov.b;
+mat.thinFilmWeight = clamp(nV.x, 0.0, 1.0);
 
 mat.thinFilmThickness *= 1000.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.baseWeight = clamp(mB.x, 0.0, 1.0);
+mat.diffuseRoughness = clamp(mB.y, 0.0, 1.0);
+mat.specularWeight = max(0.0, mB.z);
+mat.subsurfaceWeight = clamp(mB.w, 0.0, 1.0);
+mat.specularColor = max(pV.rgb, vec3(0.0));
+mat.fuzzWeight = clamp(pV.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(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);
+mat.fuzzColor = max(yj.rgb, vec3(0.0));
+mat.fuzzRoughness = clamp(yj.w, 0.0, 1.0);
+mat.coatColor = max(xr.rgb, vec3(0.0));
+mat.coatWeight = clamp(xr.w, 0.0, 1.0);
+mat.coatRoughness = clamp(mC.x, ROUGHNESS_MIN, 1.0);
+mat.coatAnisotropy = clamp(mC.y, 0.0, 1.0);
+mat.coatIor = max(mC.z, 1.0);
+mat.coatDarkening = clamp(mC.w, 0.0, 1.0);
 
 #ifdef HAS_MEDIUM
 mat.mediumExtinction = max(fetchMatData(i + MAT_ROW_MEDIUM_EXTINCTION).rgb, vec3(0.0));
@@ -223,48 +223,48 @@ mat.mediumType = max(max(mat.mediumExtinction.x, mat.mediumExtinction.y), mat.me
 
 
 #ifdef HAS_ALPHA
-mat.alpha = nB.r;
+mat.alpha = ov.r;
 #else
 mat.alpha = 1.0;
 #endif
 
 #ifdef NUM_DIFFUSE_MAPS
-int diffuseMapIndex = int(gp.z);
+int diffuseMapIndex = int(gE.z);
 if (diffuseMapIndex >= 0) {
-vec4 oa = sampleMap(
+vec4 diffuse = sampleMap(
 diffuseMapIndex, getMapUvSet(diffuseMapIndex, uv, uv1)
 );
 
 
-mat.baseColor *= decodeMapColor(diffuseMapIndex, oa.rgb);
+mat.baseColor *= decodeMapColor(diffuseMapIndex, diffuse.rgb);
 
 
 if (mapAlphaUsage == ${mapAlphaUsageConstants.transmission + ''}) {
-mat.transmissionWeight = 1.0 - oa.a;
+mat.transmissionWeight = 1.0 - diffuse.a;
 }
 else if (mapAlphaUsage == ${mapAlphaUsageConstants.alpha + ''}) {
-mat.alpha *= oa.a;
+mat.alpha *= diffuse.a;
 }
 }
 #endif
 
 ${simpleTextureSample('alphaMap', 'glsl')}
 
-mat.alpha = lr(
-mat.alpha, int(fetchMatData(i + MAT_ROW_ALPHA).w), nA.w
+mat.alpha = mb(
+mat.alpha, int(fetchMatData(i + MAT_ROW_ALPHA).w), ou.w
 );
 
 ${simpleTextureSample('transmissionMap', 'glsl')}
 
 #ifdef NUM_METALLIC_ROUGHNESS_MAPS
-int metallicRoughnessMapIndex = int(gp.w);
+int metallicRoughnessMapIndex = int(gE.w);
 if (metallicRoughnessMapIndex >= 0) {
-vec4 fO = sampleMap(
+vec4 gc = sampleMap(
 metallicRoughnessMapIndex,
 getMapUvSet(metallicRoughnessMapIndex, uv, uv1)
 );
-mat.baseMetalness *= fO.b;
-mat.specularRoughness *= fO.g;
+mat.baseMetalness *= gc.b;
+mat.specularRoughness *= gc.g;
 }
 #endif
 
@@ -273,7 +273,7 @@ ${simpleTextureSample('roughnessMap', 'glsl')}
 ${simpleTextureSample('metalnessMap', 'glsl')}
 
 #ifdef NUM_EMISSIVE_MAPS
-int emissiveMapIndex = int(hI.w);
+int emissiveMapIndex = int(hY.w);
 if (emissiveMapIndex >= 0) {
 vec3 emissive = sampleMap(
 emissiveMapIndex, getMapUvSet(emissiveMapIndex, uv, uv1)
@@ -283,12 +283,12 @@ mat.emission *= decodeMapColor(emissiveMapIndex, emissive);
 #endif
 
 #ifdef NUM_COAT_WEIGHT_MAPS
-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)
+int il = int(fetchMatData(i + MAT_ROW_LAYER_MAPS).x);
+if (il >= 0 && mat.materialType == 0) {
+float rA = clamp(xr.w, 0.0, 1.0) * sampleMap(
+il, getMapUvSet(il, uv, uv1)
 ).r;
-mat.emission *= mix(vec3(1.0), sqrt(max(vL.rgb, vec3(0.0))), qw);
+mat.emission *= mix(vec3(1.0), sqrt(max(xr.rgb, vec3(0.0))), rA);
 }
 #endif
 
@@ -297,7 +297,7 @@ ${thinFilmTextureSample('glsl')}
 ${simpleTextureSample('coatWeightMap', 'glsl')}
 #ifdef USE_COAT_NORMAL_FRAMES
 
-mat.coatNormalEnabled = mat.coatWeight > 0.0 && (fo.y >= 0.0 || fetchMatData(i + MAT_ROW_LAYER_MAPS).z >= 0.0);
+mat.coatNormalEnabled = mat.coatWeight > 0.0 && (fG.y >= 0.0 || fetchMatData(i + MAT_ROW_LAYER_MAPS).z >= 0.0);
 #endif
 
 ${simpleTextureSample('coatRoughnessMap', 'glsl')}
@@ -310,29 +310,29 @@ ${simpleTextureSample('specularWeightMap', 'glsl')}
 
 ${simpleTextureSample('specularColorMap', 'glsl')}
 
-vec4 kW = fetchMatData(i + MAT_ROW_DIRECTION_NORMAL);
+vec4 lG = fetchMatData(i + MAT_ROW_DIRECTION_NORMAL);
 mat.anisotropyDirection = vec2(1.0, 0.0);
-mat.anisotropyDirectionEnabled = kW.y != 0.0;
+mat.anisotropyDirectionEnabled = lG.y != 0.0;
 mat.coatAnisotropyRotation = fetchMatData(i + MAT_ROW_FILM_TEXTURE).x;
 #ifdef NUM_ANISOTROPY_MAPS
-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 (lG.x >= 0.0) {
+int index = int(lG.x);
+vec4 dk = sampleMap(index, getMapUvSet(index, uv, uv1));
+mat.specularAnisotropy *= dk.b;
+vec2 direction = dk.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 sF = fe(clamp(mat.specularRoughness, 0.0, 1.0), mat.specularAnisotropy);
-mat.specularRoughness = sF.x;
-mat.specularAnisotropy = sF.y;
+vec2 tU = fv(clamp(mat.specularRoughness, 0.0, 1.0), mat.specularAnisotropy);
+mat.specularRoughness = tU.x;
+mat.specularAnisotropy = tU.y;
 }
 #endif
 if (mat.anisotropyDirectionEnabled) {
-float theta = kW.y;
+float theta = lG.y;
 vec2 d = mat.anisotropyDirection;
 mat.anisotropyDirection = vec2(cos(theta)*d.x - sin(theta)*d.y, sin(theta)*d.x + cos(theta)*d.y);
 }
@@ -340,57 +340,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 hM = mat.specularRoughness * mat.specularRoughness;
-float hN = mat.coatRoughness * mat.coatRoughness;
+float ih = mat.specularRoughness * mat.specularRoughness;
+float ij = mat.coatRoughness * mat.coatRoughness;
 mat.specularRoughness = mix(mat.specularRoughness,
-pow(min(1.0, hM * hM + 2.0 * hN * hN), 0.25), mat.coatWeight);
+pow(min(1.0, ih * ih + 2.0 * ij * ij), 0.25), mat.coatWeight);
 }
-vec3 color = kI(instanceIndex) * vertexColor;
+vec3 color = lp(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);
-vec2 specularAlpha = aK(mat.specularRoughness, mat.specularAnisotropy);
+vec2 specularAlpha = aN(mat.specularRoughness, mat.specularAnisotropy);
 mat.alphaX = specularAlpha.x;
 mat.alphaY = specularAlpha.y;
 }
 
 #if defined(NUM_NORMAL_MAPS)
-vec3 ol(int materialIndex, vec2 uv, vec3 normal, vec3 dp1, vec3 dp2, vec2 oc, vec2 od) {
+vec3 pd(int materialIndex, vec2 uv, vec3 normal, vec3 dp1, vec3 dp2, vec2 oW, vec2 oX) {
 int i = materialIndex * MAT_DATA_SIZE;
-vec4 fo = fetchMatData(i + MAT_ROW_ROUGHNESS_NORMAL);
-int normalMapIndex = int(fo.y);
+vec4 fG = fetchMatData(i + MAT_ROW_ROUGHNESS_NORMAL);
+int normalMapIndex = int(fG.y);
 if (normalMapIndex >= 0) {
 
 
 
-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;
+vec3 sb = cross(dp2, normal);
+vec3 sa = cross(normal, dp1);
+vec3 dpdu = sb * oW.x + sa * oX.x;
+vec3 tH = sb * oW.y + sa * oX.y;
+float ej = max(dot(dpdu, dpdu), dot(tH, tH));
+if (ej > 1e-12) {
+float tO = inversesqrt(ej);
+dpdu *= tO;
+tH *= tO;
 }
 else {
 
 
 
-vec3 ns = abs(normal.z) < 0.999
+vec3 oo = abs(normal.z) < 0.999
 ? vec3(0.0, 0.0, 1.0)
 : vec3(0.0, 1.0, 0.0);
-dpdu = normalize(cross(ns, normal));
-sn = cross(normal, dpdu);
+dpdu = normalize(cross(oo, normal));
+tH = cross(normal, dpdu);
 }
 
 vec3 n = 2.0 * sampleMap(normalMapIndex, uv).rgb - 1.0;
-n.xy *= fo.zw;
+n.xy *= fG.zw;
 n = normalize(n);
 
-mat3 tbn = mat3(dpdu, sn, normal);
+mat3 tbn = mat3(dpdu, tH, 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,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"]}
+{"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,+BAA+B,CAAC;AACjE,OAAO,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAC;AACxE,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 '../../materialLayoutSchema.js';\nimport { materialAlphaModeConstants } from '../../materialConstants.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"]}