@meimu/mutracer 0.1.5 → 0.3.0

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

@@ -4,8 +4,8 @@ import { mapAlphaUsageConstants } from '../../materialConstants.js';
 // Portions adapted from ray-tracing-renderer@0.10.15
 // (https://github.com/hoverinc/ray-tracing-renderer).
 // Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.
-import { materialAlphaModeConstants } from '../../../scene/OpenPBRMaterial.js';
-export function createMaterialBufferWgsl({ hasAnisotropyDirections = true, hasCoatNormals = false, hasSceneAlpha = true } = {}) {
+import { materialAlphaModeConstants } from '../../materialConstants.js';
+export function createMaterialBufferWgsl({ hasAnisotropyDirections = true, hasCoatNormals = false, hasSceneAlpha = true, hasTransmission = true, caustics = false, hasMetalness = true } = {}) {
     const alphaModeAssignment = hasSceneAlpha
         ? '(*ma).alphaMode = i32(matData.alphaMode);'
         : '';
@@ -20,7 +20,7 @@ else if ((*ma).alphaMode == ${materialAlphaModeConstants.mask}) {
         : '(*ma).alpha = 1.0;';
     return /* wgsl */ `
 
-${hasAnisotropyDirections ? /* wgsl */ `fn fe(roughness: f32, strength: f32) -> vec2f {
+${hasAnisotropyDirections ? /* wgsl */ `fn fb(roughness: f32, strength: f32) -> vec2f {
 if (strength == 0.0) { return vec2f(roughness, 0.0); }
 let u = roughness * roughness;
 let a = u + (1.0 - u) * strength * strength;
@@ -29,55 +29,55 @@ return vec2f(pow((a*a + u*u) * 0.5, 0.25), clamp(1.0 - u/a, 0.0, 1.0));
 }
 ` : /* wgsl */ ``}
 
-fn oJ(c: vec3f) -> vec3f {
+fn mq(c: vec3f) -> vec3f {
 return mix(pow(c * 0.9478672986 + 0.0521327014, vec3f(2.4)), c * 0.0773993808, vec3f(c < vec3f(0.04045)));
 }
 
 fn decodeMapColor(idx: i32, c: vec3f) -> vec3f {
 if (mapInfo[idx + NUM_MAPS * 2].y > 0.5) { return c; }
-return oJ(c);
+return mq(c);
 }
 
-fn ae(val: i32) -> vec2f {
+fn af(val: i32) -> vec2f {
 return vec2f(f32(val >> 8), f32(val & 0xff) / 255.0);
 }
 
-fn kJ(idx: i32) -> vec2f {
+fn jv(idx: i32) -> vec2f {
 return mapInfo[idx].xy;
 }
 
-fn lk(idx: i32) -> i32 {
+fn lE(idx: i32) -> i32 {
 return i32(floor(mapInfo[idx].z));
 }
 
-fn jP(idx: i32) -> vec2f {
+fn jV(idx: i32) -> vec2f {
 return vec2f(fract(mapInfo[idx].z), mapInfo[idx].w);
 }
 
-fn fT(value: f32, mode: f32) -> f32 {
+fn fS(value: f32, mode: f32) -> f32 {
 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)));
 }
 
-fn kv(idx: i32, uv: vec2f) -> vec2f {
+fn kF(idx: i32, uv: vec2f) -> vec2f {
 let transform = mapInfo[idx + NUM_MAPS];
-let iK = mapInfo[idx + NUM_MAPS * 2].zw;
+let modes = mapInfo[idx + NUM_MAPS * 2].zw;
 let value = uv * transform.xy + transform.zw;
-return vec2f(fT(value.x, iK.x), fT(value.y, iK.y));
+return vec2f(fS(value.x, modes.x), fS(value.y, modes.y));
 }
 
-fn sq(idx: i32, uv: vec2f) -> vec2f {
-let qH = kv(idx, uv);
-let jk = 1.0 / vec2f(textureDimensions(map).xy);
-let dZ = jP(idx);
-let kn = kJ(idx) + jk;
-let oM = dZ - 0.5 * jk;
-let lD = dZ + kn - jk;
+fn tK(idx: i32, uv: vec2f) -> vec2f {
+let rJ = kF(idx, uv);
+let jn = 1.0 / vec2f(textureDimensions(map).xy);
+let dX = jV(idx);
+let kx = jv(idx) + jn;
+let po = dX - 0.5 * jn;
+let lS = dX + kx - jn;
 return clamp(
-oM + qH * kn,
-dZ,
-lD
+po + rJ * kx,
+dX,
+lS
 );
 }
 
@@ -86,32 +86,32 @@ return select(uv, uv1, mapInfo[idx + NUM_MAPS * 2].x > 0.5);
 }
 
 fn sampleMap(idx: i32, uv: vec2f) -> vec4f {
-let size = vec2i(round(kJ(idx) * vec2f(textureDimensions(map).xy) + vec2f(1.0)));
-let eA = kv(idx, uv) * vec2f(size) - vec2f(0.5);
-let iK = mapInfo[idx + NUM_MAPS * 2].zw;
+let size = vec2i(round(jv(idx) * vec2f(textureDimensions(map).xy) + vec2f(1.0)));
+let cR = kF(idx, uv) * vec2f(size) - vec2f(0.5);
+let modes = mapInfo[idx + NUM_MAPS * 2].zw;
 
 
-if ((size.x > 1 && iK.x < 0.5 && (eA.x < 0.0 || eA.x > f32(size.x - 1))) ||
-(size.y > 1 && iK.y < 0.5 && (eA.y < 0.0 || eA.y > f32(size.y - 1)))) {
-let base = vec2i(floor(eA));
-let weight = fract(eA);
-let origin = vec2i(round(jP(idx) * vec2f(textureDimensions(map).xy) - vec2f(0.5)));
+if ((size.x > 1 && modes.x < 0.5 && (cR.x < 0.0 || cR.x > f32(size.x - 1))) ||
+(size.y > 1 && modes.y < 0.5 && (cR.y < 0.0 || cR.y > f32(size.y - 1)))) {
+let base = vec2i(floor(cR));
+let weight = fract(cR);
+let origin = vec2i(round(jV(idx) * vec2f(textureDimensions(map).xy) - vec2f(0.5)));
 return mix(
-mix(eU(idx, base, size, origin, iK), eU(idx, base + vec2i(1, 0), size, origin, iK), weight.x),
-mix(eU(idx, base + vec2i(0, 1), size, origin, iK), eU(idx, base + vec2i(1, 1), size, origin, iK), weight.x), weight.y);
+mix(eN(idx, base, size, origin, modes), eN(idx, base + vec2i(1, 0), size, origin, modes), weight.x),
+mix(eN(idx, base + vec2i(0, 1), size, origin, modes), eN(idx, base + vec2i(1, 1), size, origin, modes), weight.x), weight.y);
 }
-return textureSampleLevel(map, mapSampler, sq(idx, uv), lk(idx), 0.0);
+return textureSampleLevel(map, mapSampler, tK(idx, uv), lE(idx), 0.0);
 }
 
-fn eU(idx: i32, jm: vec2i, size: vec2i, origin: vec2i, iK: vec2f) -> vec4f {
-var p = clamp(jm, vec2i(0), size - vec2i(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 textureLoad(map, origin + p, lk(idx), 0);
+fn eN(idx: i32, jq: vec2i, size: vec2i, origin: vec2i, modes: vec2f) -> vec4f {
+var p = clamp(jq, vec2i(0), size - vec2i(1));
+if (modes.x < 0.5) { p.x = ((jq.x % size.x) + size.x) % size.x; }
+if (modes.y < 0.5) { p.y = ((jq.y % size.y) + size.y) % size.y; }
+return textureLoad(map, origin + p, lE(idx), 0);
 }
 
 
-fn lN(materialIndex: i32, uv: vec2f, uv1: vec2f) -> vec3f {
+fn getMaterialEmission(materialIndex: i32, uv: vec2f, uv1: vec2f) -> vec3f {
 let matData = materialsBuffer[materialIndex];
 var emission = matData.emission;
 if (USE_EMISSIVE_MAPS) {
@@ -135,22 +135,22 @@ return emission;
 }
 
 
-fn aK(roughness: f32, anisotropy: f32) -> vec2f {
+fn aL(roughness: f32, anisotropy: f32) -> vec2f {
 let alpha = roughness * roughness;
-let pg = ROUGHNESS_MIN * ROUGHNESS_MIN;
-if (anisotropy == 0.0) { return vec2f(max(pg, alpha)); }
-let di = 1.0 - anisotropy;
-let sh = alpha * sqrt(2.0 / (1.0 + di * di));
-return max(vec2f(pg), vec2f(sh, di * sh));
+let pZ = ROUGHNESS_MIN * ROUGHNESS_MIN;
+if (anisotropy == 0.0) { return vec2f(max(pZ, alpha)); }
+let cY = 1.0 - anisotropy;
+let tp = alpha * sqrt(2.0 / (1.0 + cY * cY));
+return max(vec2f(pZ), vec2f(tp, cY * tp));
 }
 
-fn kI(instanceIndex: i32) -> vec3f {
+fn kV(instanceIndex: i32) -> vec3f {
 if (instanceIndex < 0) { return vec3f(1.0); }
 return instancesBuffer[instanceIndex * ${INSTANCE_VEC4_STRIDE} + 9].xyz;
 }
 
-fn eX(
-ma: ptr<function, J>,
+fn getMaterial(
+ma: ptr<function, OpenPbrResolvedMaterial>,
 materialIndex: i32,
 uv: vec2f,
 uv1: vec2f,
@@ -164,7 +164,7 @@ let matData = materialsBuffer[materialIndex];
 (*ma).specularRoughness = matData.roughness;
 (*ma).baseMetalness = matData.metallic;
 (*ma).specularAnisotropy = clamp(matData.anisotropy, 0.0, 1.0);
-(*ma).emission = lN(materialIndex, uv, uv1);
+(*ma).emission = getMaterialEmission(materialIndex, uv, uv1);
 (*ma).inside = false;
 (*ma).specularIor = matData.ior;
 (*ma).transmissionWeight = matData.transmission;
@@ -203,19 +203,19 @@ if (USE_DIFFUSE_MAPS) {
 let diffuseMapIndex = i32(matData.diffuseMapIndex);
 if (diffuseMapIndex >= 0) {
 
-let oa = sampleMap(
+let diffuse = sampleMap(
 diffuseMapIndex, getMapUvSet(diffuseMapIndex, uv, uv1)
 );
 
 
-(*ma).baseColor *= decodeMapColor(diffuseMapIndex, oa.rgb);
+(*ma).baseColor *= decodeMapColor(diffuseMapIndex, diffuse.rgb);
 
 
 if (matData.mapAlphaUsage == ${mapAlphaUsageConstants.transmission}) {
-(*ma).transmissionWeight = 1.0 - oa.a;
+(*ma).transmissionWeight = 1.0 - diffuse.a;
 }
 else if (matData.mapAlphaUsage == ${mapAlphaUsageConstants.alpha}) {
-(*ma).alpha *= oa.a;
+(*ma).alpha *= diffuse.a;
 }
 }
 }
@@ -267,16 +267,16 @@ ${hasAnisotropyDirections ? /* wgsl */ `
 (*ma).coatAnisotropyRotation = matData.coatAnisotropyRotation;
 if (USE_ANISOTROPY_MAPS && matData.anisotropyMapIndex >= 0.0) {
 let index = i32(matData.anisotropyMapIndex);
-let eA = sampleMap(index, getMapUvSet(index, uv, uv1));
-(*ma).specularAnisotropy *= eA.b;
-let direction = eA.rg * 2.0 - 1.0;
+let cR = sampleMap(index, getMapUvSet(index, uv, uv1));
+(*ma).specularAnisotropy *= cR.b;
+let direction = cR.rg * 2.0 - 1.0;
 if (dot(direction, direction) > 1e-4) { (*ma).anisotropyDirection = normalize(direction); }
 (*ma).anisotropyDirectionEnabled = true;
 }
 if (matData.specularAnisotropyModel > 0.5 && (*ma).specularAnisotropy > 0.0) {
-let sF = fe(clamp((*ma).specularRoughness, 0.0, 1.0), (*ma).specularAnisotropy);
-(*ma).specularRoughness = sF.x;
-(*ma).specularAnisotropy = sF.y;
+let tX = fb(clamp((*ma).specularRoughness, 0.0, 1.0), (*ma).specularAnisotropy);
+(*ma).specularRoughness = tX.x;
+(*ma).specularAnisotropy = tX.y;
 }
 if ((*ma).anisotropyDirectionEnabled) {
 let theta = matData.specularAnisotropyRotation;
@@ -288,55 +288,59 @@ let d = (*ma).anisotropyDirection;
 
 
 if ((*ma).coatWeight > 0.0 && (*ma).coatRoughness > 0.0) {
-let hM = (*ma).specularRoughness * (*ma).specularRoughness;
-let hN = (*ma).coatRoughness * (*ma).coatRoughness;
+let hJ = (*ma).specularRoughness * (*ma).specularRoughness;
+let hK = (*ma).coatRoughness * (*ma).coatRoughness;
 (*ma).specularRoughness = mix((*ma).specularRoughness,
-pow(min(1.0, hM * hM + 2.0 * hN * hN), 0.25), (*ma).coatWeight);
+pow(min(1.0, hJ * hJ + 2.0 * hK * hK), 0.25), (*ma).coatWeight);
 }
-let color = kI(instanceIndex) * vertexColor;
+${hasTransmission ? '' : /* wgsl */ `(*ma).transmissionWeight = 0.0;`}
+${hasMetalness ? '' : /* wgsl */ `(*ma).baseMetalness = 0.0;`}
+let color = kV(instanceIndex) * vertexColor;
 (*ma).baseColor *= color;
 if ((*ma).materialType == UNLIT) { (*ma).emission *= color; }
 
-(*ma).specularRoughness = clamp((*ma).specularRoughness, ROUGHNESS_MIN, 1.0);
+${caustics ? /* wgsl */ `  (*ma).causticRoughness = (*ma).specularRoughness;
+(*ma).causticNormalMapped = matData.normalMapIndex >= 0.0;
+` : ''}  (*ma).specularRoughness = clamp((*ma).specularRoughness, ROUGHNESS_MIN, 1.0);
 (*ma).baseMetalness = clamp((*ma).baseMetalness, 0.0, 1.0);
-let specularAlpha = aK((*ma).specularRoughness, (*ma).specularAnisotropy);
+let specularAlpha = aL((*ma).specularRoughness, (*ma).specularAnisotropy);
 (*ma).alphaX = specularAlpha.x;
 (*ma).alphaY = specularAlpha.y;
 }
 
-fn ol(materialIndex: i32, uv: vec2f, normal: vec3f, dp1: vec3f, dp2: vec3f, oc: vec2f, od: vec2f) -> vec3f {
+fn oS(materialIndex: i32, uv: vec2f, normal: vec3f, dp1: vec3f, dp2: vec3f, oM: vec2f, oN: vec2f) -> vec3f {
 let matData = materialsBuffer[materialIndex];
 let normalMapIndex = i32(matData.normalMapIndex);
 if (normalMapIndex >= 0) {
 
 
 
-let qW = cross(dp2, normal);
-let qV = cross(normal, dp1);
-var dpdu = qW * oc.x + qV * od.x;
-var sn = qW * oc.y + qV * od.y;
-let dT = max(dot(dpdu, dpdu), dot(sn, sn));
+let rX = cross(dp2, normal);
+let rW = cross(normal, dp1);
+var dpdu = rX * oM.x + rW * oN.x;
+var tI = rX * oM.y + rW * oN.y;
+let dT = max(dot(dpdu, dpdu), dot(tI, tI));
 if (dT > 1e-12) {
-let sz = inverseSqrt(dT);
-dpdu *= sz;
-sn *= sz;
+let tQ = inverseSqrt(dT);
+dpdu *= tQ;
+tI *= tQ;
 }
 else {
 
 
-let ns = select(
+let ob = select(
 vec3f(0.0, 1.0, 0.0),
 vec3f(0.0, 0.0, 1.0),
 abs(normal.z) < 0.999
 );
-dpdu = normalize(cross(ns, normal));
-sn = cross(normal, dpdu);
+dpdu = normalize(cross(ob, normal));
+tI = cross(normal, dpdu);
 }
 
 var n = 2.0 * sampleMap(normalMapIndex, uv).rgb - 1.0;
 n = normalize(vec3(n.xy * matData.normalMapScale, n.z));
 
-let tbn = mat3x3(dpdu, sn, normal);
+let tbn = mat3x3(dpdu, tI, normal);
 
 return normalize(tbn * n);
 } else {

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

@@ -1 +1 @@
-{"version":3,"file":"materialBuffer.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/materialBuffer.wgsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAC3F,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,OAAO,EACL,0BAA0B,EAC3B,MAAM,mCAAmC,CAAC;AAE3C,MAAM,UAAU,wBAAwB,CAAC,EACvC,uBAAuB,GAAG,IAAI,EAC9B,cAAc,GAAG,KAAK,EACtB,aAAa,GAAG,IAAI,KAKlB,EAAE;IACJ,MAAM,mBAAmB,GAAG,aAAa;QACvC,CAAC,CAAC,2CAA2C;QAC7C,CAAC,CAAC,EAAE,CAAC;IACP,MAAM,mBAAmB,GAAG,aAAa;QACvC,CAAC,CAAC,UAAU,CAAC;yBACU,0BAA0B,CAAC,MAAM;;;8BAG5B,0BAA0B,CAAC,IAAI;;EAE3D;QACA,CAAC,CAAC,oBAAoB,CAAC;IAEzB,OAAO,UAAU,CAAC;;EAElB,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;;;CAOtC,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAuH0B,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+B3D,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAkCc,sBAAsB,CAAC,YAAY;;;oCAG9B,sBAAsB,CAAC,KAAK;;;;;;EAMlE,mBAAmB,CAAC,UAAU,EAAE,MAAM,CAAC;;EAEvC,mBAAmB;;EAEnB,mBAAmB,CAAC,iBAAiB,EAAE,MAAM,CAAC;;;;;;;;;;;;;;EAc9C,mBAAmB,CAAC,cAAc,EAAE,MAAM,CAAC;;EAE3C,mBAAmB,CAAC,cAAc,EAAE,MAAM,CAAC;;EAE3C,qBAAqB,CAAC,MAAM,CAAC;;EAE7B,mBAAmB,CAAC,eAAe,EAAE,MAAM,CAAC;;EAE9C,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;;;CAG7B,CAAC,CAAC,CAAC,EAAE;;EAEF,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;;EAEjD,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuBtC,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DhB,CAAC;AACF,CAAC;AAED,MAAM,kBAAkB,GAAG,wBAAwB,EAAE,CAAC;AAEtD,eAAe,kBAAkB,CAAC","sourcesContent":["import { simpleTextureSample, thinFilmTextureSample } from '../../materialTextureSlots.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 {\n  materialAlphaModeConstants\n} from '../../../scene/OpenPBRMaterial.js';\n\nexport function createMaterialBufferWgsl({\n  hasAnisotropyDirections = true,\n  hasCoatNormals = false,\n  hasSceneAlpha = true\n}: {\n  hasSceneAlpha?: boolean;\n  hasAnisotropyDirections?: boolean;\n  hasCoatNormals?: boolean;\n} = {}) {\n  const alphaModeAssignment = hasSceneAlpha\n    ? '(*ma).alphaMode = i32(matData.alphaMode);'\n    : '';\n  const alphaModeResolution = hasSceneAlpha\n    ? /* wgsl */ `\n  if ((*ma).alphaMode == ${materialAlphaModeConstants.opaque}) {\n    (*ma).alpha = 1.0;\n  }\n  else if ((*ma).alphaMode == ${materialAlphaModeConstants.mask}) {\n    (*ma).alpha = select(0.0, 1.0, (*ma).alpha >= matData.alphaCutoff);\n  }`\n    : '(*ma).alpha = 1.0;';\n\n  return /* wgsl */ `\n\n${hasAnisotropyDirections ? /* wgsl */ `fn gltf_anisotropy_to_openpbr(roughness: f32, strength: f32) -> vec2f {\n  if (strength == 0.0) { return vec2f(roughness, 0.0); }\n  let u = roughness * roughness;\n  let a = u + (1.0 - u) * strength * strength;\n  if (a == 0.0) { return vec2f(0.0); }\n  return vec2f(pow((a*a + u*u) * 0.5, 0.25), clamp(1.0 - u/a, 0.0, 1.0));\n}\n` : /* wgsl */ ``}\n\nfn sRGBToLinear(c: vec3f) -> vec3f {\n  return mix(pow(c * 0.9478672986 + 0.0521327014, vec3f(2.4)), c * 0.0773993808, vec3f(c < vec3f(0.04045)));\n}\n\nfn decodeMapColor(idx: i32, c: vec3f) -> vec3f {\n  if (mapInfo[idx + NUM_MAPS * 2].y > 0.5) { return c; }\n  return sRGBToLinear(c);\n}\n\nfn unpackMaterialIndex(val: i32) -> vec2f {\n  return vec2f(f32(val >> 8), f32(val & 0xff) / 255.0);\n}\n\nfn getMapSize(idx: i32) -> vec2f {\n  return mapInfo[idx].xy;\n}\n\nfn getMapLayer(idx: i32) -> i32 {\n  return i32(floor(mapInfo[idx].z));\n}\n\nfn getMapOffset(idx: i32) -> vec2f {\n  return vec2f(fract(mapInfo[idx].z), mapInfo[idx].w);\n}\n\nfn wrapMapCoordinate(value: f32, mode: f32) -> f32 {\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\nfn wrappedMapUv(idx: i32, uv: vec2f) -> vec2f {\n  let transform = mapInfo[idx + NUM_MAPS];\n  let modes = mapInfo[idx + NUM_MAPS * 2].zw;\n  let value = uv * transform.xy + transform.zw;\n  return vec2f(wrapMapCoordinate(value.x, modes.x), wrapMapCoordinate(value.y, modes.y));\n}\n\nfn getMapUV(idx: i32, uv: vec2f) -> vec2f {\n  let repeatedUv = wrappedMapUv(idx, uv);\n  let atlasTexel = 1.0 / vec2f(textureDimensions(map).xy);\n  let firstTexelCenter = getMapOffset(idx);\n  let sourceExtent = getMapSize(idx) + atlasTexel;\n  let sourceOrigin = firstTexelCenter - 0.5 * atlasTexel;\n  let lastTexelCenter = firstTexelCenter + sourceExtent - atlasTexel;\n  return clamp(\n    sourceOrigin + repeatedUv * sourceExtent,\n    firstTexelCenter,\n    lastTexelCenter\n  );\n}\n\nfn getMapUvSet(idx: i32, uv: vec2f, uv1: vec2f) -> vec2f {\n  return select(uv, uv1, mapInfo[idx + NUM_MAPS * 2].x > 0.5);\n}\n\nfn sampleMap(idx: i32, uv: vec2f) -> vec4f {\n  let size = vec2i(round(getMapSize(idx) * vec2f(textureDimensions(map).xy) + vec2f(1.0)));\n  let texel = wrappedMapUv(idx, uv) * vec2f(size) - vec2f(0.5);\n  let modes = mapInfo[idx + NUM_MAPS * 2].zw;\n  // Repeat filtering must cross the logical image boundary, never another\n  // atlas placement. Interior/clamped/mirrored footprints use hardware filtering.\n  if ((size.x > 1 && modes.x < 0.5 && (texel.x < 0.0 || texel.x > f32(size.x - 1))) ||\n      (size.y > 1 && modes.y < 0.5 && (texel.y < 0.0 || texel.y > f32(size.y - 1)))) {\n    let base = vec2i(floor(texel));\n    let weight = fract(texel);\n    let origin = vec2i(round(getMapOffset(idx) * vec2f(textureDimensions(map).xy) - vec2f(0.5)));\n    return mix(\n      mix(loadMapTexel(idx, base, size, origin, modes), loadMapTexel(idx, base + vec2i(1, 0), size, origin, modes), weight.x),\n      mix(loadMapTexel(idx, base + vec2i(0, 1), size, origin, modes), loadMapTexel(idx, base + vec2i(1, 1), size, origin, modes), weight.x), weight.y);\n  }\n  return textureSampleLevel(map, mapSampler, getMapUV(idx, uv), getMapLayer(idx), 0.0);\n}\n\nfn loadMapTexel(idx: i32, coordinate: vec2i, size: vec2i, origin: vec2i, modes: vec2f) -> vec4f {\n  var p = clamp(coordinate, vec2i(0), size - vec2i(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 textureLoad(map, origin + p, getMapLayer(idx), 0);\n}\n\n\nfn getMaterialEmission(materialIndex: i32, uv: vec2f, uv1: vec2f) -> vec3f {\n  let matData = materialsBuffer[materialIndex];\n  var emission = matData.emission;\n  if (USE_EMISSIVE_MAPS) {\n    let emissiveMapIndex = i32(matData.emissiveMapIndex);\n    if (emissiveMapIndex >= 0) {\n      emission *= decodeMapColor(emissiveMapIndex, sampleMap(\n        emissiveMapIndex, getMapUvSet(emissiveMapIndex, uv, uv1)\n      ).rgb);\n    }\n  }\n  if (USE_COAT_WEIGHT_MAPS && matData.matType == 0.0) {\n    let coatWeightMapIndex = i32(matData.coatWeightMapIndex);\n    if (coatWeightMapIndex >= 0) {\n      let coatWeight = clamp(matData.coatWeight, 0.0, 1.0) * sampleMap(\n        coatWeightMapIndex, getMapUvSet(coatWeightMapIndex, uv, uv1)\n      ).r;\n      emission *= mix(vec3f(1.0), sqrt(max(matData.coatColor, vec3f(0.0))), coatWeight);\n    }\n  }\n  return emission;\n}\n\n// OpenPBR 1.1.1: RMS-preserving GGX anisotropy, shared by base and coat.\nfn openpbr_roughness_to_alpha(roughness: f32, anisotropy: f32) -> vec2f {\n  let alpha = roughness * roughness;\n  let alphaMin = ROUGHNESS_MIN * ROUGHNESS_MIN;\n  if (anisotropy == 0.0) { return vec2f(max(alphaMin, alpha)); }\n  let complement = 1.0 - anisotropy;\n  let alphaT = alpha * sqrt(2.0 / (1.0 + complement * complement));\n  return max(vec2f(alphaMin), vec2f(alphaT, complement * alphaT));\n}\n\nfn getInstanceColor(instanceIndex: i32) -> vec3f {\n  if (instanceIndex < 0) { return vec3f(1.0); }\n  return instancesBuffer[instanceIndex * ${INSTANCE_VEC4_STRIDE} + 9].xyz;\n}\n\nfn getMaterial(\n  ma: ptr<function, OpenPbrResolvedMaterial>,\n  materialIndex: i32,\n  uv: vec2f,\n  uv1: vec2f,\n  instanceIndex: i32,\n  vertexColor: vec3f\n) {\n  let matData = materialsBuffer[materialIndex];\n\n  (*ma).baseColor = matData.color;\n  (*ma).materialType = i32(matData.matType);\n  (*ma).specularRoughness = matData.roughness;\n  (*ma).baseMetalness = matData.metallic;\n  (*ma).specularAnisotropy = clamp(matData.anisotropy, 0.0, 1.0);\n  (*ma).emission = getMaterialEmission(materialIndex, uv, uv1);\n  (*ma).inside = false;\n  (*ma).specularIor = matData.ior;\n  (*ma).transmissionWeight = matData.transmission;\n  (*ma).thinWalled = matData.thin > 0.5;\n  (*ma).bevel = matData.bevel;\n  (*ma).transmissionDispersionScale = matData.dispersion;\n  (*ma).dispersionAbbeNumber = max(matData.dispersionAbbeNumber, 1e-6);\n  (*ma).mediumExtinction = max(matData.mediumExtinction, vec3f(0.0));\n  (*ma).mediumScattering = max(matData.mediumScattering, vec3f(0.0));\n  (*ma).mediumAnisotropy = clamp(matData.mediumAnisotropy, -1.0, 1.0);\n  (*ma).mediumType = select(0, 1, max(max((*ma).mediumExtinction.x, (*ma).mediumExtinction.y), (*ma).mediumExtinction.z) > 0.0);\n  (*ma).alpha = matData.alpha;\n  ${alphaModeAssignment}\n\n  (*ma).thinFilmThickness = matData.thinFilmThickness * 1000.0;\n  (*ma).thinFilmIor = matData.thinFilmIor;\n  (*ma).thinFilmWeight = select(0.0, clamp(matData.thinFilmWeight, 0.0, 1.0), HAS_THIN_FILM);\n  (*ma).baseWeight = clamp(matData.baseWeight, 0.0, 1.0);\n  (*ma).diffuseRoughness = clamp(matData.baseDiffuseRoughness, 0.0, 1.0);\n  (*ma).specularWeight = max(matData.specularWeight, 0.0);\n  (*ma).specularColor = max(matData.specularColor, vec3f(0.0));\n  (*ma).subsurfaceWeight = select(0.0, clamp(matData.subsurfaceWeight, 0.0, 1.0), HAS_SUBSURFACE);\n  (*ma).subsurfaceColor = max(matData.subsurfaceColor, vec3f(0.0));\n  (*ma).transmissionColor = max(matData.transmissionColor, vec3f(0.0));\n  (*ma).fuzzWeight = select(0.0, clamp(matData.fuzzWeight, 0.0, 1.0), HAS_FUZZ);\n  (*ma).fuzzColor = max(matData.fuzzColor, vec3f(0.0));\n  (*ma).fuzzRoughness = clamp(matData.fuzzRoughness, 0.0, 1.0);\n  (*ma).coatWeight = select(0.0, clamp(matData.coatWeight, 0.0, 1.0), HAS_COAT);\n  (*ma).coatColor = max(matData.coatColor, vec3f(0.0));\n  (*ma).coatRoughness = clamp(matData.coatRoughness, ROUGHNESS_MIN, 1.0);\n  (*ma).coatAnisotropy = clamp(matData.coatAnisotropy, 0.0, 1.0);\n  (*ma).coatIor = max(matData.coatIor, 1.0);\n  (*ma).coatDarkening = clamp(matData.coatDarkening, 0.0, 1.0);\n\n  if (USE_DIFFUSE_MAPS) {\n    let diffuseMapIndex = i32(matData.diffuseMapIndex);\n    if (diffuseMapIndex >= 0) {\n      // TODO textureSample is not supported in compute shader.\n      let 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      (*ma).baseColor *= decodeMapColor(diffuseMapIndex, diffuse.rgb);\n\n      // Map alpha to transmission\n      if (matData.mapAlphaUsage == ${mapAlphaUsageConstants.transmission}) {\n        (*ma).transmissionWeight = 1.0 - diffuse.a;\n      }\n      else if (matData.mapAlphaUsage == ${mapAlphaUsageConstants.alpha}) {\n        (*ma).alpha *= diffuse.a;\n      }\n    }\n  }\n\n  ${simpleTextureSample('alphaMap', 'wgsl')}\n\n  ${alphaModeResolution}\n\n  ${simpleTextureSample('transmissionMap', 'wgsl')}\n\n  if (USE_METALLIC_ROUGHNESS_MAPS) {\n    // Metallic roughness transmission map index\n    let mrtMapIndex = i32(matData.mrtMapIndex);\n    if (mrtMapIndex >= 0) {\n      let metallicRoughness = sampleMap(\n        mrtMapIndex, getMapUvSet(mrtMapIndex, uv, uv1)\n      );\n      (*ma).baseMetalness *= metallicRoughness.b;\n      (*ma).specularRoughness *= metallicRoughness.g;\n    }\n  }\n\n  ${simpleTextureSample('roughnessMap', 'wgsl')}\n\n  ${simpleTextureSample('metalnessMap', 'wgsl')}\n\n  ${thinFilmTextureSample('wgsl')}\n\n  ${simpleTextureSample('coatWeightMap', 'wgsl')}\n\n${hasCoatNormals ? /* wgsl */ `\n  // Independent coat shading also applies when the coat has no normal map.\n  (*ma).coatNormalEnabled = (*ma).coatWeight > 0.0 && (matData.normalMapIndex >= 0.0 || matData.coatNormalMapIndex >= 0.0);\n` : ''}\n\n  ${simpleTextureSample('coatRoughnessMap', 'wgsl')}\n\n  ${simpleTextureSample('fuzzColorMap', 'wgsl')}\n\n  ${simpleTextureSample('fuzzRoughnessMap', 'wgsl')}\n\n  ${simpleTextureSample('specularWeightMap', 'wgsl')}\n\n  ${simpleTextureSample('specularColorMap', 'wgsl')}\n\n${hasAnisotropyDirections ? /* wgsl */ `\n  (*ma).anisotropyDirection = vec2f(1.0, 0.0);\n  (*ma).anisotropyDirectionEnabled = matData.specularAnisotropyRotation != 0.0;\n  (*ma).coatAnisotropyRotation = matData.coatAnisotropyRotation;\n  if (USE_ANISOTROPY_MAPS && matData.anisotropyMapIndex >= 0.0) {\n    let index = i32(matData.anisotropyMapIndex);\n    let texel = sampleMap(index, getMapUvSet(index, uv, uv1));\n    (*ma).specularAnisotropy *= texel.b;\n    let direction = texel.rg * 2.0 - 1.0;\n    if (dot(direction, direction) > 1e-4) { (*ma).anisotropyDirection = normalize(direction); }\n    (*ma).anisotropyDirectionEnabled = true;\n  }\n  if (matData.specularAnisotropyModel > 0.5 && (*ma).specularAnisotropy > 0.0) {\n    let native = gltf_anisotropy_to_openpbr(clamp((*ma).specularRoughness, 0.0, 1.0), (*ma).specularAnisotropy);\n    (*ma).specularRoughness = native.x;\n    (*ma).specularAnisotropy = native.y;\n  }\n  if ((*ma).anisotropyDirectionEnabled) {\n    let theta = matData.specularAnisotropyRotation;\n    let d = (*ma).anisotropyDirection;\n    (*ma).anisotropyDirection = vec2f(cos(theta)*d.x - sin(theta)*d.y, sin(theta)*d.x + cos(theta)*d.y);\n  }\n\n` : /* wgsl */ ``}\n  // OpenPBR 1.1.1: coat refraction broadens all base microfacet lobes.\n  // Keep the zero-coat / smooth-coat paths byte-identical.\n  if ((*ma).coatWeight > 0.0 && (*ma).coatRoughness > 0.0) {\n    let baseRoughness2 = (*ma).specularRoughness * (*ma).specularRoughness;\n    let coatRoughness2 = (*ma).coatRoughness * (*ma).coatRoughness;\n    (*ma).specularRoughness = mix((*ma).specularRoughness,\n      pow(min(1.0, baseRoughness2 * baseRoughness2 + 2.0 * coatRoughness2 * coatRoughness2), 0.25), (*ma).coatWeight);\n  }\n  let color = getInstanceColor(instanceIndex) * vertexColor;\n  (*ma).baseColor *= color;\n  if ((*ma).materialType == UNLIT) { (*ma).emission *= color; }\n\n  (*ma).specularRoughness = clamp((*ma).specularRoughness, ROUGHNESS_MIN, 1.0);\n  (*ma).baseMetalness = clamp((*ma).baseMetalness, 0.0, 1.0);\n  let specularAlpha = openpbr_roughness_to_alpha((*ma).specularRoughness, (*ma).specularAnisotropy);\n  (*ma).alphaX = specularAlpha.x;\n  (*ma).alphaY = specularAlpha.y;\n}\n\nfn getMatNormal(materialIndex: i32, uv: vec2f, normal: vec3f, dp1: vec3f, dp2: vec3f, duv1: vec2f, duv2: vec2f) -> vec3f {\n  let matData = materialsBuffer[materialIndex];\n  let normalMapIndex = i32(matData.normalMapIndex);\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    let dp2perp = cross(dp2, normal);\n    let dp1perp = cross(normal, dp1);\n    var dpdu = dp2perp * duv1.x + dp1perp * duv2.x;\n    var dpdv = dp2perp * duv1.y + dp1perp * duv2.y;\n    let gradientLengthSquared = max(dot(dpdu, dpdu), dot(dpdv, dpdv));\n    if (gradientLengthSquared > 1e-12) {\n      let invmax = inverseSqrt(gradientLengthSquared);\n      dpdu *= invmax;\n      dpdv *= invmax;\n    }\n    else {\n      // Generated/triplanar UVs have no per-vertex UV derivatives. Build a\n      // stable fallback basis instead of normalizing two zero vectors.\n      let referenceAxis = select(\n        vec3f(0.0, 1.0, 0.0),\n        vec3f(0.0, 0.0, 1.0),\n        abs(normal.z) < 0.999\n      );\n      dpdu = normalize(cross(referenceAxis, normal));\n      dpdv = cross(normal, dpdu);\n    }\n\n    var n = 2.0 * sampleMap(normalMapIndex, uv).rgb - 1.0;\n    n = normalize(vec3(n.xy * matData.normalMapScale, n.z));\n\n    let tbn = mat3x3(dpdu, dpdv, normal);\n\n    return normalize(tbn * n);\n  } else {\n    return normal;\n  }\n}\n`;\n}\n\nconst materialBufferWgsl = createMaterialBufferWgsl();\n\nexport default materialBufferWgsl;\n"]}
+{"version":3,"file":"materialBuffer.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/materialBuffer.wgsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAC3F,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,OAAO,EACL,0BAA0B,EAC3B,MAAM,4BAA4B,CAAC;AAEpC,MAAM,UAAU,wBAAwB,CAAC,EACvC,uBAAuB,GAAG,IAAI,EAC9B,cAAc,GAAG,KAAK,EACtB,aAAa,GAAG,IAAI,EACpB,eAAe,GAAG,IAAI,EAAE,QAAQ,GAAG,KAAK,EACxC,YAAY,GAAG,IAAI,KAOjB,EAAE;IACJ,MAAM,mBAAmB,GAAG,aAAa;QACvC,CAAC,CAAC,2CAA2C;QAC7C,CAAC,CAAC,EAAE,CAAC;IACP,MAAM,mBAAmB,GAAG,aAAa;QACvC,CAAC,CAAC,UAAU,CAAC;yBACU,0BAA0B,CAAC,MAAM;;;8BAG5B,0BAA0B,CAAC,IAAI;;EAE3D;QACA,CAAC,CAAC,oBAAoB,CAAC;IAEzB,OAAO,UAAU,CAAC;;EAElB,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;;;CAOtC,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAuH0B,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+B3D,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAkCc,sBAAsB,CAAC,YAAY;;;oCAG9B,sBAAsB,CAAC,KAAK;;;;;;EAMlE,mBAAmB,CAAC,UAAU,EAAE,MAAM,CAAC;;EAEvC,mBAAmB;;EAEnB,mBAAmB,CAAC,iBAAiB,EAAE,MAAM,CAAC;;;;;;;;;;;;;;EAc9C,mBAAmB,CAAC,cAAc,EAAE,MAAM,CAAC;;EAE3C,mBAAmB,CAAC,cAAc,EAAE,MAAM,CAAC;;EAE3C,qBAAqB,CAAC,MAAM,CAAC;;EAE7B,mBAAmB,CAAC,eAAe,EAAE,MAAM,CAAC;;EAE9C,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC;;;CAG7B,CAAC,CAAC,CAAC,EAAE;;EAEF,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;;EAEjD,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuBtC,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE;;;;;;;;;EASb,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,iCAAiC;EACnE,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,4BAA4B;;;;;EAK7D,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC;;CAEvB,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CL,CAAC;AACF,CAAC;AAED,MAAM,kBAAkB,GAAG,wBAAwB,EAAE,CAAC;AAEtD,eAAe,kBAAkB,CAAC","sourcesContent":["import { simpleTextureSample, thinFilmTextureSample } from '../../materialTextureSlots.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 {\n  materialAlphaModeConstants\n} from '../../materialConstants.js';\n\nexport function createMaterialBufferWgsl({\n  hasAnisotropyDirections = true,\n  hasCoatNormals = false,\n  hasSceneAlpha = true,\n  hasTransmission = true, caustics = false,\n  hasMetalness = true\n}: {\n  hasSceneAlpha?: boolean;\n  hasAnisotropyDirections?: boolean;\n  hasCoatNormals?: boolean;\n  hasTransmission?: boolean; caustics?: boolean;\n  hasMetalness?: boolean;\n} = {}) {\n  const alphaModeAssignment = hasSceneAlpha\n    ? '(*ma).alphaMode = i32(matData.alphaMode);'\n    : '';\n  const alphaModeResolution = hasSceneAlpha\n    ? /* wgsl */ `\n  if ((*ma).alphaMode == ${materialAlphaModeConstants.opaque}) {\n    (*ma).alpha = 1.0;\n  }\n  else if ((*ma).alphaMode == ${materialAlphaModeConstants.mask}) {\n    (*ma).alpha = select(0.0, 1.0, (*ma).alpha >= matData.alphaCutoff);\n  }`\n    : '(*ma).alpha = 1.0;';\n\n  return /* wgsl */ `\n\n${hasAnisotropyDirections ? /* wgsl */ `fn gltf_anisotropy_to_openpbr(roughness: f32, strength: f32) -> vec2f {\n  if (strength == 0.0) { return vec2f(roughness, 0.0); }\n  let u = roughness * roughness;\n  let a = u + (1.0 - u) * strength * strength;\n  if (a == 0.0) { return vec2f(0.0); }\n  return vec2f(pow((a*a + u*u) * 0.5, 0.25), clamp(1.0 - u/a, 0.0, 1.0));\n}\n` : /* wgsl */ ``}\n\nfn sRGBToLinear(c: vec3f) -> vec3f {\n  return mix(pow(c * 0.9478672986 + 0.0521327014, vec3f(2.4)), c * 0.0773993808, vec3f(c < vec3f(0.04045)));\n}\n\nfn decodeMapColor(idx: i32, c: vec3f) -> vec3f {\n  if (mapInfo[idx + NUM_MAPS * 2].y > 0.5) { return c; }\n  return sRGBToLinear(c);\n}\n\nfn unpackMaterialIndex(val: i32) -> vec2f {\n  return vec2f(f32(val >> 8), f32(val & 0xff) / 255.0);\n}\n\nfn getMapSize(idx: i32) -> vec2f {\n  return mapInfo[idx].xy;\n}\n\nfn getMapLayer(idx: i32) -> i32 {\n  return i32(floor(mapInfo[idx].z));\n}\n\nfn getMapOffset(idx: i32) -> vec2f {\n  return vec2f(fract(mapInfo[idx].z), mapInfo[idx].w);\n}\n\nfn wrapMapCoordinate(value: f32, mode: f32) -> f32 {\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\nfn wrappedMapUv(idx: i32, uv: vec2f) -> vec2f {\n  let transform = mapInfo[idx + NUM_MAPS];\n  let modes = mapInfo[idx + NUM_MAPS * 2].zw;\n  let value = uv * transform.xy + transform.zw;\n  return vec2f(wrapMapCoordinate(value.x, modes.x), wrapMapCoordinate(value.y, modes.y));\n}\n\nfn getMapUV(idx: i32, uv: vec2f) -> vec2f {\n  let repeatedUv = wrappedMapUv(idx, uv);\n  let atlasTexel = 1.0 / vec2f(textureDimensions(map).xy);\n  let firstTexelCenter = getMapOffset(idx);\n  let sourceExtent = getMapSize(idx) + atlasTexel;\n  let sourceOrigin = firstTexelCenter - 0.5 * atlasTexel;\n  let lastTexelCenter = firstTexelCenter + sourceExtent - atlasTexel;\n  return clamp(\n    sourceOrigin + repeatedUv * sourceExtent,\n    firstTexelCenter,\n    lastTexelCenter\n  );\n}\n\nfn getMapUvSet(idx: i32, uv: vec2f, uv1: vec2f) -> vec2f {\n  return select(uv, uv1, mapInfo[idx + NUM_MAPS * 2].x > 0.5);\n}\n\nfn sampleMap(idx: i32, uv: vec2f) -> vec4f {\n  let size = vec2i(round(getMapSize(idx) * vec2f(textureDimensions(map).xy) + vec2f(1.0)));\n  let texel = wrappedMapUv(idx, uv) * vec2f(size) - vec2f(0.5);\n  let modes = mapInfo[idx + NUM_MAPS * 2].zw;\n  // Repeat filtering must cross the logical image boundary, never another\n  // atlas placement. Interior/clamped/mirrored footprints use hardware filtering.\n  if ((size.x > 1 && modes.x < 0.5 && (texel.x < 0.0 || texel.x > f32(size.x - 1))) ||\n      (size.y > 1 && modes.y < 0.5 && (texel.y < 0.0 || texel.y > f32(size.y - 1)))) {\n    let base = vec2i(floor(texel));\n    let weight = fract(texel);\n    let origin = vec2i(round(getMapOffset(idx) * vec2f(textureDimensions(map).xy) - vec2f(0.5)));\n    return mix(\n      mix(loadMapTexel(idx, base, size, origin, modes), loadMapTexel(idx, base + vec2i(1, 0), size, origin, modes), weight.x),\n      mix(loadMapTexel(idx, base + vec2i(0, 1), size, origin, modes), loadMapTexel(idx, base + vec2i(1, 1), size, origin, modes), weight.x), weight.y);\n  }\n  return textureSampleLevel(map, mapSampler, getMapUV(idx, uv), getMapLayer(idx), 0.0);\n}\n\nfn loadMapTexel(idx: i32, coordinate: vec2i, size: vec2i, origin: vec2i, modes: vec2f) -> vec4f {\n  var p = clamp(coordinate, vec2i(0), size - vec2i(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 textureLoad(map, origin + p, getMapLayer(idx), 0);\n}\n\n\nfn getMaterialEmission(materialIndex: i32, uv: vec2f, uv1: vec2f) -> vec3f {\n  let matData = materialsBuffer[materialIndex];\n  var emission = matData.emission;\n  if (USE_EMISSIVE_MAPS) {\n    let emissiveMapIndex = i32(matData.emissiveMapIndex);\n    if (emissiveMapIndex >= 0) {\n      emission *= decodeMapColor(emissiveMapIndex, sampleMap(\n        emissiveMapIndex, getMapUvSet(emissiveMapIndex, uv, uv1)\n      ).rgb);\n    }\n  }\n  if (USE_COAT_WEIGHT_MAPS && matData.matType == 0.0) {\n    let coatWeightMapIndex = i32(matData.coatWeightMapIndex);\n    if (coatWeightMapIndex >= 0) {\n      let coatWeight = clamp(matData.coatWeight, 0.0, 1.0) * sampleMap(\n        coatWeightMapIndex, getMapUvSet(coatWeightMapIndex, uv, uv1)\n      ).r;\n      emission *= mix(vec3f(1.0), sqrt(max(matData.coatColor, vec3f(0.0))), coatWeight);\n    }\n  }\n  return emission;\n}\n\n// OpenPBR 1.1.1: RMS-preserving GGX anisotropy, shared by base and coat.\nfn openpbr_roughness_to_alpha(roughness: f32, anisotropy: f32) -> vec2f {\n  let alpha = roughness * roughness;\n  let alphaMin = ROUGHNESS_MIN * ROUGHNESS_MIN;\n  if (anisotropy == 0.0) { return vec2f(max(alphaMin, alpha)); }\n  let complement = 1.0 - anisotropy;\n  let alphaT = alpha * sqrt(2.0 / (1.0 + complement * complement));\n  return max(vec2f(alphaMin), vec2f(alphaT, complement * alphaT));\n}\n\nfn getInstanceColor(instanceIndex: i32) -> vec3f {\n  if (instanceIndex < 0) { return vec3f(1.0); }\n  return instancesBuffer[instanceIndex * ${INSTANCE_VEC4_STRIDE} + 9].xyz;\n}\n\nfn getMaterial(\n  ma: ptr<function, OpenPbrResolvedMaterial>,\n  materialIndex: i32,\n  uv: vec2f,\n  uv1: vec2f,\n  instanceIndex: i32,\n  vertexColor: vec3f\n) {\n  let matData = materialsBuffer[materialIndex];\n\n  (*ma).baseColor = matData.color;\n  (*ma).materialType = i32(matData.matType);\n  (*ma).specularRoughness = matData.roughness;\n  (*ma).baseMetalness = matData.metallic;\n  (*ma).specularAnisotropy = clamp(matData.anisotropy, 0.0, 1.0);\n  (*ma).emission = getMaterialEmission(materialIndex, uv, uv1);\n  (*ma).inside = false;\n  (*ma).specularIor = matData.ior;\n  (*ma).transmissionWeight = matData.transmission;\n  (*ma).thinWalled = matData.thin > 0.5;\n  (*ma).bevel = matData.bevel;\n  (*ma).transmissionDispersionScale = matData.dispersion;\n  (*ma).dispersionAbbeNumber = max(matData.dispersionAbbeNumber, 1e-6);\n  (*ma).mediumExtinction = max(matData.mediumExtinction, vec3f(0.0));\n  (*ma).mediumScattering = max(matData.mediumScattering, vec3f(0.0));\n  (*ma).mediumAnisotropy = clamp(matData.mediumAnisotropy, -1.0, 1.0);\n  (*ma).mediumType = select(0, 1, max(max((*ma).mediumExtinction.x, (*ma).mediumExtinction.y), (*ma).mediumExtinction.z) > 0.0);\n  (*ma).alpha = matData.alpha;\n  ${alphaModeAssignment}\n\n  (*ma).thinFilmThickness = matData.thinFilmThickness * 1000.0;\n  (*ma).thinFilmIor = matData.thinFilmIor;\n  (*ma).thinFilmWeight = select(0.0, clamp(matData.thinFilmWeight, 0.0, 1.0), HAS_THIN_FILM);\n  (*ma).baseWeight = clamp(matData.baseWeight, 0.0, 1.0);\n  (*ma).diffuseRoughness = clamp(matData.baseDiffuseRoughness, 0.0, 1.0);\n  (*ma).specularWeight = max(matData.specularWeight, 0.0);\n  (*ma).specularColor = max(matData.specularColor, vec3f(0.0));\n  (*ma).subsurfaceWeight = select(0.0, clamp(matData.subsurfaceWeight, 0.0, 1.0), HAS_SUBSURFACE);\n  (*ma).subsurfaceColor = max(matData.subsurfaceColor, vec3f(0.0));\n  (*ma).transmissionColor = max(matData.transmissionColor, vec3f(0.0));\n  (*ma).fuzzWeight = select(0.0, clamp(matData.fuzzWeight, 0.0, 1.0), HAS_FUZZ);\n  (*ma).fuzzColor = max(matData.fuzzColor, vec3f(0.0));\n  (*ma).fuzzRoughness = clamp(matData.fuzzRoughness, 0.0, 1.0);\n  (*ma).coatWeight = select(0.0, clamp(matData.coatWeight, 0.0, 1.0), HAS_COAT);\n  (*ma).coatColor = max(matData.coatColor, vec3f(0.0));\n  (*ma).coatRoughness = clamp(matData.coatRoughness, ROUGHNESS_MIN, 1.0);\n  (*ma).coatAnisotropy = clamp(matData.coatAnisotropy, 0.0, 1.0);\n  (*ma).coatIor = max(matData.coatIor, 1.0);\n  (*ma).coatDarkening = clamp(matData.coatDarkening, 0.0, 1.0);\n\n  if (USE_DIFFUSE_MAPS) {\n    let diffuseMapIndex = i32(matData.diffuseMapIndex);\n    if (diffuseMapIndex >= 0) {\n      // TODO textureSample is not supported in compute shader.\n      let 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      (*ma).baseColor *= decodeMapColor(diffuseMapIndex, diffuse.rgb);\n\n      // Map alpha to transmission\n      if (matData.mapAlphaUsage == ${mapAlphaUsageConstants.transmission}) {\n        (*ma).transmissionWeight = 1.0 - diffuse.a;\n      }\n      else if (matData.mapAlphaUsage == ${mapAlphaUsageConstants.alpha}) {\n        (*ma).alpha *= diffuse.a;\n      }\n    }\n  }\n\n  ${simpleTextureSample('alphaMap', 'wgsl')}\n\n  ${alphaModeResolution}\n\n  ${simpleTextureSample('transmissionMap', 'wgsl')}\n\n  if (USE_METALLIC_ROUGHNESS_MAPS) {\n    // Metallic roughness transmission map index\n    let mrtMapIndex = i32(matData.mrtMapIndex);\n    if (mrtMapIndex >= 0) {\n      let metallicRoughness = sampleMap(\n        mrtMapIndex, getMapUvSet(mrtMapIndex, uv, uv1)\n      );\n      (*ma).baseMetalness *= metallicRoughness.b;\n      (*ma).specularRoughness *= metallicRoughness.g;\n    }\n  }\n\n  ${simpleTextureSample('roughnessMap', 'wgsl')}\n\n  ${simpleTextureSample('metalnessMap', 'wgsl')}\n\n  ${thinFilmTextureSample('wgsl')}\n\n  ${simpleTextureSample('coatWeightMap', 'wgsl')}\n\n${hasCoatNormals ? /* wgsl */ `\n  // Independent coat shading also applies when the coat has no normal map.\n  (*ma).coatNormalEnabled = (*ma).coatWeight > 0.0 && (matData.normalMapIndex >= 0.0 || matData.coatNormalMapIndex >= 0.0);\n` : ''}\n\n  ${simpleTextureSample('coatRoughnessMap', 'wgsl')}\n\n  ${simpleTextureSample('fuzzColorMap', 'wgsl')}\n\n  ${simpleTextureSample('fuzzRoughnessMap', 'wgsl')}\n\n  ${simpleTextureSample('specularWeightMap', 'wgsl')}\n\n  ${simpleTextureSample('specularColorMap', 'wgsl')}\n\n${hasAnisotropyDirections ? /* wgsl */ `\n  (*ma).anisotropyDirection = vec2f(1.0, 0.0);\n  (*ma).anisotropyDirectionEnabled = matData.specularAnisotropyRotation != 0.0;\n  (*ma).coatAnisotropyRotation = matData.coatAnisotropyRotation;\n  if (USE_ANISOTROPY_MAPS && matData.anisotropyMapIndex >= 0.0) {\n    let index = i32(matData.anisotropyMapIndex);\n    let texel = sampleMap(index, getMapUvSet(index, uv, uv1));\n    (*ma).specularAnisotropy *= texel.b;\n    let direction = texel.rg * 2.0 - 1.0;\n    if (dot(direction, direction) > 1e-4) { (*ma).anisotropyDirection = normalize(direction); }\n    (*ma).anisotropyDirectionEnabled = true;\n  }\n  if (matData.specularAnisotropyModel > 0.5 && (*ma).specularAnisotropy > 0.0) {\n    let native = gltf_anisotropy_to_openpbr(clamp((*ma).specularRoughness, 0.0, 1.0), (*ma).specularAnisotropy);\n    (*ma).specularRoughness = native.x;\n    (*ma).specularAnisotropy = native.y;\n  }\n  if ((*ma).anisotropyDirectionEnabled) {\n    let theta = matData.specularAnisotropyRotation;\n    let d = (*ma).anisotropyDirection;\n    (*ma).anisotropyDirection = vec2f(cos(theta)*d.x - sin(theta)*d.y, sin(theta)*d.x + cos(theta)*d.y);\n  }\n\n` : /* wgsl */ ``}\n  // OpenPBR 1.1.1: coat refraction broadens all base microfacet lobes.\n  // Keep the zero-coat / smooth-coat paths byte-identical.\n  if ((*ma).coatWeight > 0.0 && (*ma).coatRoughness > 0.0) {\n    let baseRoughness2 = (*ma).specularRoughness * (*ma).specularRoughness;\n    let coatRoughness2 = (*ma).coatRoughness * (*ma).coatRoughness;\n    (*ma).specularRoughness = mix((*ma).specularRoughness,\n      pow(min(1.0, baseRoughness2 * baseRoughness2 + 2.0 * coatRoughness2 * coatRoughness2), 0.25), (*ma).coatWeight);\n  }\n  ${hasTransmission ? '' : /* wgsl */ `(*ma).transmissionWeight = 0.0;`}\n  ${hasMetalness ? '' : /* wgsl */ `(*ma).baseMetalness = 0.0;`}\n  let color = getInstanceColor(instanceIndex) * vertexColor;\n  (*ma).baseColor *= color;\n  if ((*ma).materialType == UNLIT) { (*ma).emission *= color; }\n\n${caustics ? /* wgsl */ `  (*ma).causticRoughness = (*ma).specularRoughness;\n  (*ma).causticNormalMapped = matData.normalMapIndex >= 0.0;\n` : ''}  (*ma).specularRoughness = clamp((*ma).specularRoughness, ROUGHNESS_MIN, 1.0);\n  (*ma).baseMetalness = clamp((*ma).baseMetalness, 0.0, 1.0);\n  let specularAlpha = openpbr_roughness_to_alpha((*ma).specularRoughness, (*ma).specularAnisotropy);\n  (*ma).alphaX = specularAlpha.x;\n  (*ma).alphaY = specularAlpha.y;\n}\n\nfn getMatNormal(materialIndex: i32, uv: vec2f, normal: vec3f, dp1: vec3f, dp2: vec3f, duv1: vec2f, duv2: vec2f) -> vec3f {\n  let matData = materialsBuffer[materialIndex];\n  let normalMapIndex = i32(matData.normalMapIndex);\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    let dp2perp = cross(dp2, normal);\n    let dp1perp = cross(normal, dp1);\n    var dpdu = dp2perp * duv1.x + dp1perp * duv2.x;\n    var dpdv = dp2perp * duv1.y + dp1perp * duv2.y;\n    let gradientLengthSquared = max(dot(dpdu, dpdu), dot(dpdv, dpdv));\n    if (gradientLengthSquared > 1e-12) {\n      let invmax = inverseSqrt(gradientLengthSquared);\n      dpdu *= invmax;\n      dpdv *= invmax;\n    }\n    else {\n      // Generated/triplanar UVs have no per-vertex UV derivatives. Build a\n      // stable fallback basis instead of normalizing two zero vectors.\n      let referenceAxis = select(\n        vec3f(0.0, 1.0, 0.0),\n        vec3f(0.0, 0.0, 1.0),\n        abs(normal.z) < 0.999\n      );\n      dpdu = normalize(cross(referenceAxis, normal));\n      dpdv = cross(normal, dpdu);\n    }\n\n    var n = 2.0 * sampleMap(normalMapIndex, uv).rgb - 1.0;\n    n = normalize(vec3(n.xy * matData.normalMapScale, n.z));\n\n    let tbn = mat3x3(dpdu, dpdv, normal);\n\n    return normalize(tbn * n);\n  } else {\n    return normal;\n  }\n}\n`;\n}\n\nconst materialBufferWgsl = createMaterialBufferWgsl();\n\nexport default materialBufferWgsl;\n"]}