@zephyr3d/scene 0.9.25 → 0.9.27

package/dist/shadow/shader.js.map

@@ -1 +1 @@
-{"version":3,"file":"shader.js","sources":["../../src/shadow/shader.ts"],"sourcesContent":["import type { PBInsideFunctionScope, PBShaderExp } from '@zephyr3d/device';\r\nimport { ShaderHelper } from '../material';\r\nimport { LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT } from '../values';\r\n\r\nfunction getShadowReceiverBiasFactors(scope: PBInsideFunctionScope) {\r\n  const pb = scope.$builder;\r\n  const alphaCutoff = (scope as PBInsideFunctionScope & { zAlphaCutoff?: PBShaderExp }).zAlphaCutoff;\r\n  if (alphaCutoff) {\r\n    // Thin masked geometry such as layered hair cards needs a tighter receiver bias,\r\n    // otherwise nearby layers lose self-shadow before the shadow map is even sampled.\r\n    const cutoff = pb.clamp(alphaCutoff, 0, 1);\r\n    return pb.vec2(pb.mix(0.22, 0.4, cutoff), pb.mix(0.05, 0.16, cutoff)) as PBShaderExp;\r\n  }\r\n  return pb.vec2(1, 1) as PBShaderExp;\r\n}\r\n\r\nfunction isMaskedPerspectiveShadowLight(scope: PBInsideFunctionScope, lightType: number) {\r\n  const alphaCutoff = (scope as PBInsideFunctionScope & { zAlphaCutoff?: PBShaderExp }).zAlphaCutoff;\r\n  return !!alphaCutoff && (lightType === LIGHT_TYPE_SPOT || lightType === LIGHT_TYPE_POINT);\r\n}\r\n\r\nfunction getShadowReceiverNoL(scope: PBInsideFunctionScope, NdotL: PBShaderExp, lightType?: number) {\r\n  const pb = scope.$builder;\r\n  const alphaCutoff = (scope as PBInsideFunctionScope & { zAlphaCutoff?: PBShaderExp }).zAlphaCutoff;\r\n  if (alphaCutoff) {\r\n    // Layered masked cards should not explode slope bias at grazing angles.\r\n    // This is especially visible for back / rim spot lights on hair cards.\r\n    const cutoff = pb.clamp(alphaCutoff, 0, 1);\r\n    if (lightType != null && isMaskedPerspectiveShadowLight(scope, lightType)) {\r\n      return pb.max(NdotL, pb.mix(0.85, 0.95, cutoff)) as PBShaderExp;\r\n    }\r\n    return pb.max(NdotL, pb.mix(0.45, 0.65, cutoff)) as PBShaderExp;\r\n  }\r\n  return NdotL as PBShaderExp;\r\n}\r\n\r\nfunction getShadowReceiverPerspectiveBiasScale(\r\n  scope: PBInsideFunctionScope,\r\n  lightType: number,\r\n  linearDepth: PBShaderExp,\r\n  farNearRatio: PBShaderExp\r\n) {\r\n  const pb = scope.$builder;\r\n  const alphaCutoff = (scope as PBInsideFunctionScope & { zAlphaCutoff?: PBShaderExp }).zAlphaCutoff;\r\n  if (alphaCutoff && isMaskedPerspectiveShadowLight(scope, lightType)) {\r\n    const cutoff = pb.clamp(alphaCutoff, 0, 1);\r\n    // Perspective shadow cameras (spot / point) can over-amplify receiver bias at depth.\r\n    // Keep masked layered geometry in a much tighter range so hair cards can still self-occlude.\r\n    const cappedFarNearRatio = pb.min(farNearRatio, pb.mix(1.15, 1.6, cutoff));\r\n    return pb.mix(1, cappedFarNearRatio, linearDepth) as PBShaderExp;\r\n  }\r\n  return pb.mix(1, farNearRatio, linearDepth) as PBShaderExp;\r\n}\r\n\r\nexport function computeShadowBiasCSM(scope: PBInsideFunctionScope, NdotL: PBShaderExp, split: PBShaderExp) {\r\n  const pb = scope.$builder;\r\n  const depthBiasParam = ShaderHelper.getDepthBiasValues(scope);\r\n  const splitFlags = pb.vec4(\r\n    pb.float(pb.equal(split, 0)),\r\n    pb.float(pb.equal(split, 1)),\r\n    pb.float(pb.equal(split, 2)),\r\n    pb.float(pb.equal(split, 3))\r\n  );\r\n  const depthBiasScale = pb.dot(ShaderHelper.getDepthBiasScales(scope), splitFlags);\r\n  const receiverBiasFactors = getShadowReceiverBiasFactors(scope);\r\n  const receiverNoL = getShadowReceiverNoL(scope, NdotL);\r\n  return pb.dot(\r\n    pb.mul(depthBiasParam.xy, receiverBiasFactors, pb.vec2(1, pb.sub(1, receiverNoL)), depthBiasScale),\r\n    pb.vec2(1, 1)\r\n  );\r\n}\r\n\r\nexport function computeShadowBias(\r\n  lightType: number,\r\n  scope: PBInsideFunctionScope,\r\n  z: PBShaderExp,\r\n  NdotL: PBShaderExp,\r\n  linear: boolean\r\n) {\r\n  const pb = scope.$builder;\r\n  const depthBiasParam = ShaderHelper.getDepthBiasValues(scope);\r\n  const receiverBiasFactors = getShadowReceiverBiasFactors(scope);\r\n  const receiverNoL = getShadowReceiverNoL(scope, NdotL, lightType);\r\n  if (lightType === LIGHT_TYPE_DIRECTIONAL) {\r\n    return pb.dot(\r\n      pb.mul(depthBiasParam.xy, receiverBiasFactors, pb.vec2(1, pb.sub(1, receiverNoL))),\r\n      pb.vec2(1, 1)\r\n    );\r\n  } else {\r\n    const nearFar = ShaderHelper.getShadowCameraParams(scope).xy;\r\n    const linearDepth = linear ? z : ShaderHelper.nonLinearDepthToLinearNormalized(scope, z, nearFar);\r\n    const biasScaleFactor = getShadowReceiverPerspectiveBiasScale(\r\n      scope,\r\n      lightType,\r\n      linearDepth,\r\n      depthBiasParam.w\r\n    );\r\n    let bias = pb.dot(\r\n      pb.mul(depthBiasParam.xy, receiverBiasFactors, pb.vec2(1, pb.sub(1, receiverNoL)), biasScaleFactor),\r\n      pb.vec2(1, 1)\r\n    );\r\n    if (isMaskedPerspectiveShadowLight(scope, lightType)) {\r\n      const alphaCutoff = (scope as PBInsideFunctionScope & { zAlphaCutoff?: PBShaderExp }).zAlphaCutoff!;\r\n      bias = pb.mul(bias, pb.mix(0.12, 0.22, pb.clamp(alphaCutoff, 0, 1))) as PBShaderExp;\r\n    }\r\n    return bias;\r\n  }\r\n}\r\n"],"names":["getShadowReceiverBiasFactors","scope","pb","$builder","alphaCutoff","zAlphaCutoff","cutoff","clamp","vec2","mix","isMaskedPerspectiveShadowLight","lightType","LIGHT_TYPE_SPOT","LIGHT_TYPE_POINT","getShadowReceiverNoL","NdotL","max","getShadowReceiverPerspectiveBiasScale","linearDepth","farNearRatio","cappedFarNearRatio","min","computeShadowBiasCSM","split","depthBiasParam","ShaderHelper","getDepthBiasValues","splitFlags","vec4","float","equal","depthBiasScale","dot","getDepthBiasScales","receiverBiasFactors","receiverNoL","mul","xy","sub","computeShadowBias","z","linear","LIGHT_TYPE_DIRECTIONAL","nearFar","getShadowCameraParams","nonLinearDepthToLinearNormalized","biasScaleFactor","w","bias"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAIA,SAASA,6BAA6BC,KAA4B,EAAA;IAChE,MAAMC,EAAAA,GAAKD,MAAME,QAAQ;IACzB,MAAMC,WAAAA,GAAc,KAACH,CAAiEI,YAAY;AAClG,IAAA,IAAID,WAAa,EAAA;;;AAGf,QAAA,MAAME,MAASJ,GAAAA,EAAAA,CAAGK,KAAK,CAACH,aAAa,CAAG,EAAA,CAAA,CAAA;AACxC,QAAA,OAAOF,EAAGM,CAAAA,IAAI,CAACN,EAAAA,CAAGO,GAAG,CAAC,IAAM,EAAA,GAAA,EAAKH,MAASJ,CAAAA,EAAAA,EAAAA,CAAGO,GAAG,CAAC,MAAM,IAAMH,EAAAA,MAAAA,CAAAA,CAAAA;AAC/D;IACA,OAAOJ,EAAAA,CAAGM,IAAI,CAAC,CAAG,EAAA,CAAA,CAAA;AACpB;AAEA,SAASE,8BAAAA,CAA+BT,KAA4B,EAAEU,SAAiB,EAAA;IACrF,MAAMP,WAAAA,GAAc,KAACH,CAAiEI,YAAY;AAClG,IAAA,OAAO,CAAC,CAACD,WAAAA,KAAgBO,SAAcC,KAAAA,eAAAA,IAAmBD,cAAcE,gBAAe,CAAA;AACzF;AAEA,SAASC,oBAAqBb,CAAAA,KAA4B,EAAEc,KAAkB,EAAEJ,SAAkB,EAAA;IAChG,MAAMT,EAAAA,GAAKD,MAAME,QAAQ;IACzB,MAAMC,WAAAA,GAAc,KAACH,CAAiEI,YAAY;AAClG,IAAA,IAAID,WAAa,EAAA;;;AAGf,QAAA,MAAME,MAASJ,GAAAA,EAAAA,CAAGK,KAAK,CAACH,aAAa,CAAG,EAAA,CAAA,CAAA;AACxC,QAAA,IAAIO,SAAa,IAAA,IAAA,IAAQD,8BAA+BT,CAAAA,KAAAA,EAAOU,SAAY,CAAA,EAAA;YACzE,OAAOT,EAAAA,CAAGc,GAAG,CAACD,KAAAA,EAAOb,GAAGO,GAAG,CAAC,MAAM,IAAMH,EAAAA,MAAAA,CAAAA,CAAAA;AAC1C;QACA,OAAOJ,EAAAA,CAAGc,GAAG,CAACD,KAAAA,EAAOb,GAAGO,GAAG,CAAC,MAAM,IAAMH,EAAAA,MAAAA,CAAAA,CAAAA;AAC1C;IACA,OAAOS,KAAAA;AACT;AAEA,SAASE,sCACPhB,KAA4B,EAC5BU,SAAiB,EACjBO,WAAwB,EACxBC,YAAyB,EAAA;IAEzB,MAAMjB,EAAAA,GAAKD,MAAME,QAAQ;IACzB,MAAMC,WAAAA,GAAc,KAACH,CAAiEI,YAAY;IAClG,IAAID,WAAAA,IAAeM,8BAA+BT,CAAAA,KAAAA,EAAOU,SAAY,CAAA,EAAA;AACnE,QAAA,MAAML,MAASJ,GAAAA,EAAAA,CAAGK,KAAK,CAACH,aAAa,CAAG,EAAA,CAAA,CAAA;;;QAGxC,MAAMgB,kBAAAA,GAAqBlB,GAAGmB,GAAG,CAACF,cAAcjB,EAAGO,CAAAA,GAAG,CAAC,IAAA,EAAM,GAAKH,EAAAA,MAAAA,CAAAA,CAAAA;AAClE,QAAA,OAAOJ,EAAGO,CAAAA,GAAG,CAAC,CAAA,EAAGW,kBAAoBF,EAAAA,WAAAA,CAAAA;AACvC;AACA,IAAA,OAAOhB,EAAGO,CAAAA,GAAG,CAAC,CAAA,EAAGU,YAAcD,EAAAA,WAAAA,CAAAA;AACjC;AAEO,SAASI,oBAAqBrB,CAAAA,KAA4B,EAAEc,KAAkB,EAAEQ,KAAkB,EAAA;IACvG,MAAMrB,EAAAA,GAAKD,MAAME,QAAQ;IACzB,MAAMqB,cAAAA,GAAiBC,YAAaC,CAAAA,kBAAkB,CAACzB,KAAAA,CAAAA;AACvD,IAAA,MAAM0B,UAAazB,GAAAA,EAAAA,CAAG0B,IAAI,CACxB1B,GAAG2B,KAAK,CAAC3B,EAAG4B,CAAAA,KAAK,CAACP,KAAO,EAAA,CAAA,CAAA,CAAA,EACzBrB,EAAG2B,CAAAA,KAAK,CAAC3B,EAAG4B,CAAAA,KAAK,CAACP,KAAAA,EAAO,CACzBrB,CAAAA,CAAAA,EAAAA,EAAAA,CAAG2B,KAAK,CAAC3B,GAAG4B,KAAK,CAACP,KAAO,EAAA,CAAA,CAAA,CAAA,EACzBrB,GAAG2B,KAAK,CAAC3B,EAAG4B,CAAAA,KAAK,CAACP,KAAO,EAAA,CAAA,CAAA,CAAA,CAAA;AAE3B,IAAA,MAAMQ,iBAAiB7B,EAAG8B,CAAAA,GAAG,CAACP,YAAaQ,CAAAA,kBAAkB,CAAChC,KAAQ0B,CAAAA,EAAAA,UAAAA,CAAAA;AACtE,IAAA,MAAMO,sBAAsBlC,4BAA6BC,CAAAA,KAAAA,CAAAA;IACzD,MAAMkC,WAAAA,GAAcrB,qBAAqBb,KAAOc,EAAAA,KAAAA,CAAAA;IAChD,OAAOb,EAAAA,CAAG8B,GAAG,CACX9B,EAAAA,CAAGkC,GAAG,CAACZ,cAAAA,CAAea,EAAE,EAAEH,mBAAqBhC,EAAAA,EAAAA,CAAGM,IAAI,CAAC,CAAA,EAAGN,EAAGoC,CAAAA,GAAG,CAAC,CAAA,EAAGH,eAAeJ,cACnF7B,CAAAA,EAAAA,EAAAA,CAAGM,IAAI,CAAC,CAAG,EAAA,CAAA,CAAA,CAAA;AAEf;AAEO,SAAS+B,iBACd5B,CAAAA,SAAiB,EACjBV,KAA4B,EAC5BuC,CAAc,EACdzB,KAAkB,EAClB0B,MAAe,EAAA;IAEf,MAAMvC,EAAAA,GAAKD,MAAME,QAAQ;IACzB,MAAMqB,cAAAA,GAAiBC,YAAaC,CAAAA,kBAAkB,CAACzB,KAAAA,CAAAA;AACvD,IAAA,MAAMiC,sBAAsBlC,4BAA6BC,CAAAA,KAAAA,CAAAA;IACzD,MAAMkC,WAAAA,GAAcrB,oBAAqBb,CAAAA,KAAAA,EAAOc,KAAOJ,EAAAA,SAAAA,CAAAA;AACvD,IAAA,IAAIA,cAAc+B,sBAAwB,EAAA;QACxC,OAAOxC,EAAAA,CAAG8B,GAAG,CACX9B,EAAAA,CAAGkC,GAAG,CAACZ,cAAAA,CAAea,EAAE,EAAEH,mBAAqBhC,EAAAA,EAAAA,CAAGM,IAAI,CAAC,CAAA,EAAGN,GAAGoC,GAAG,CAAC,GAAGH,WACpEjC,CAAAA,CAAAA,CAAAA,EAAAA,EAAAA,CAAGM,IAAI,CAAC,CAAG,EAAA,CAAA,CAAA,CAAA;KAER,MAAA;AACL,QAAA,MAAMmC,OAAUlB,GAAAA,YAAAA,CAAamB,qBAAqB,CAAC3C,OAAOoC,EAAE;AAC5D,QAAA,MAAMnB,cAAcuB,MAASD,GAAAA,CAAAA,GAAIf,aAAaoB,gCAAgC,CAAC5C,OAAOuC,CAAGG,EAAAA,OAAAA,CAAAA;AACzF,QAAA,MAAMG,kBAAkB7B,qCACtBhB,CAAAA,KAAAA,EACAU,SACAO,EAAAA,WAAAA,EACAM,eAAeuB,CAAC,CAAA;QAElB,IAAIC,IAAAA,GAAO9C,EAAG8B,CAAAA,GAAG,CACf9B,EAAAA,CAAGkC,GAAG,CAACZ,cAAAA,CAAea,EAAE,EAAEH,mBAAqBhC,EAAAA,EAAAA,CAAGM,IAAI,CAAC,CAAA,EAAGN,EAAGoC,CAAAA,GAAG,CAAC,CAAA,EAAGH,eAAeW,eACnF5C,CAAAA,EAAAA,EAAAA,CAAGM,IAAI,CAAC,CAAG,EAAA,CAAA,CAAA,CAAA;QAEb,IAAIE,8BAAAA,CAA+BT,OAAOU,SAAY,CAAA,EAAA;YACpD,MAAMP,WAAAA,GAAc,KAACH,CAAiEI,YAAY;AAClG2C,YAAAA,IAAAA,GAAO9C,EAAGkC,CAAAA,GAAG,CAACY,IAAAA,EAAM9C,EAAGO,CAAAA,GAAG,CAAC,IAAA,EAAM,IAAMP,EAAAA,EAAAA,CAAGK,KAAK,CAACH,aAAa,CAAG,EAAA,CAAA,CAAA,CAAA,CAAA;AAClE;QACA,OAAO4C,IAAAA;AACT;AACF;;;;"}
+{"version":3,"file":"shader.js","sources":["../../src/shadow/shader.ts"],"sourcesContent":["import type { PBInsideFunctionScope, PBShaderExp } from '@zephyr3d/device';\r\nimport { ShaderHelper } from '../material/shader/helper';\r\nimport { LIGHT_TYPE_DIRECTIONAL } from '../values';\r\nimport { getShadowReceiverBiasFactor, isMaskedPerspectiveShadowLight } from './receiver_bias';\r\n\r\nfunction getShadowReceiverPerspectiveBiasScale(\r\n  scope: PBInsideFunctionScope,\r\n  lightType: number,\r\n  linearDepth: PBShaderExp,\r\n  farNearRatio: PBShaderExp\r\n) {\r\n  const pb = scope.$builder;\r\n  const alphaCutoff = (scope as PBInsideFunctionScope & { zAlphaCutoff?: PBShaderExp }).zAlphaCutoff;\r\n  if (alphaCutoff && isMaskedPerspectiveShadowLight(scope, lightType)) {\r\n    const cutoff = pb.clamp(alphaCutoff, 0, 1);\r\n    // Perspective shadow cameras (spot / point) can over-amplify receiver bias at depth.\r\n    // Keep masked layered geometry in a much tighter range so hair cards can still self-occlude.\r\n    const cappedFarNearRatio = pb.min(farNearRatio, pb.mix(1.15, 1.6, cutoff));\r\n    return pb.mix(1, cappedFarNearRatio, linearDepth) as PBShaderExp;\r\n  }\r\n  return pb.mix(1, farNearRatio, linearDepth) as PBShaderExp;\r\n}\r\n\r\n/**\r\n * Constant depth bias for a cascaded directional shadow.\r\n *\r\n * @remarks\r\n * The slope-scaled term that used to occupy `depthBiasValues.y` is gone: `.y`\r\n * now carries the normal offset distance, and normal offsetting (see\r\n * `ShaderHelper.applyShadowNormalOffset`) is what handles receiver slope. A\r\n * depth bias cannot, because the depth spanned by one texel diverges as the\r\n * surface turns away from the light.\r\n */\r\nexport function computeShadowBiasCSM(scope: PBInsideFunctionScope, _NdotL: PBShaderExp, split: PBShaderExp) {\r\n  const pb = scope.$builder;\r\n  return pb.mul(\r\n    ShaderHelper.getDepthBiasValues(scope).x,\r\n    getShadowReceiverBiasFactor(scope),\r\n    ShaderHelper.getShadowCascadeBiasScale(scope, split)\r\n  );\r\n}\r\n\r\n/**\r\n * Constant depth bias for a single-cascade shadow. See {@link computeShadowBiasCSM}\r\n * for why there is no slope-scaled term.\r\n */\r\nexport function computeShadowBias(\r\n  lightType: number,\r\n  scope: PBInsideFunctionScope,\r\n  z: PBShaderExp,\r\n  _NdotL: PBShaderExp,\r\n  linear: boolean\r\n) {\r\n  const pb = scope.$builder;\r\n  const depthBiasParam = ShaderHelper.getDepthBiasValues(scope);\r\n  const receiverBiasFactor = getShadowReceiverBiasFactor(scope);\r\n  if (lightType === LIGHT_TYPE_DIRECTIONAL) {\r\n    return pb.mul(depthBiasParam.x, receiverBiasFactor);\r\n  } else {\r\n    const nearFar = ShaderHelper.getShadowCameraParams(scope).xy;\r\n    const linearDepth = linear ? z : ShaderHelper.nonLinearDepthToLinearNormalized(scope, z, nearFar);\r\n    const biasScaleFactor = getShadowReceiverPerspectiveBiasScale(\r\n      scope,\r\n      lightType,\r\n      linearDepth,\r\n      depthBiasParam.w\r\n    );\r\n    let bias = pb.mul(depthBiasParam.x, receiverBiasFactor, biasScaleFactor) as PBShaderExp;\r\n    if (isMaskedPerspectiveShadowLight(scope, lightType)) {\r\n      const alphaCutoff = (scope as PBInsideFunctionScope & { zAlphaCutoff?: PBShaderExp }).zAlphaCutoff!;\r\n      bias = pb.mul(bias, pb.mix(0.12, 0.22, pb.clamp(alphaCutoff, 0, 1))) as PBShaderExp;\r\n    }\r\n    return bias;\r\n  }\r\n}\r\n"],"names":["getShadowReceiverPerspectiveBiasScale","scope","lightType","linearDepth","farNearRatio","pb","$builder","alphaCutoff","zAlphaCutoff","isMaskedPerspectiveShadowLight","cutoff","clamp","cappedFarNearRatio","min","mix","computeShadowBiasCSM","_NdotL","split","mul","ShaderHelper","getDepthBiasValues","x","getShadowReceiverBiasFactor","getShadowCascadeBiasScale","computeShadowBias","z","linear","depthBiasParam","receiverBiasFactor","LIGHT_TYPE_DIRECTIONAL","nearFar","getShadowCameraParams","xy","nonLinearDepthToLinearNormalized","biasScaleFactor","w","bias"],"mappings":";;;;AAKA,SAASA,sCACPC,KAA4B,EAC5BC,SAAiB,EACjBC,WAAwB,EACxBC,YAAyB,EAAA;IAEzB,MAAMC,EAAAA,GAAKJ,MAAMK,QAAQ;IACzB,MAAMC,WAAAA,GAAc,KAACN,CAAiEO,YAAY;IAClG,IAAID,WAAAA,IAAeE,8BAA+BR,CAAAA,KAAAA,EAAOC,SAAY,CAAA,EAAA;AACnE,QAAA,MAAMQ,MAASL,GAAAA,EAAAA,CAAGM,KAAK,CAACJ,aAAa,CAAG,EAAA,CAAA,CAAA;;;QAGxC,MAAMK,kBAAAA,GAAqBP,GAAGQ,GAAG,CAACT,cAAcC,EAAGS,CAAAA,GAAG,CAAC,IAAA,EAAM,GAAKJ,EAAAA,MAAAA,CAAAA,CAAAA;AAClE,QAAA,OAAOL,EAAGS,CAAAA,GAAG,CAAC,CAAA,EAAGF,kBAAoBT,EAAAA,WAAAA,CAAAA;AACvC;AACA,IAAA,OAAOE,EAAGS,CAAAA,GAAG,CAAC,CAAA,EAAGV,YAAcD,EAAAA,WAAAA,CAAAA;AACjC;AAEA;;;;;;;;;AASC,IACM,SAASY,oBAAAA,CAAqBd,KAA4B,EAAEe,MAAmB,EAAEC,KAAkB,EAAA;IACxG,MAAMZ,EAAAA,GAAKJ,MAAMK,QAAQ;AACzB,IAAA,OAAOD,EAAGa,CAAAA,GAAG,CACXC,YAAAA,CAAaC,kBAAkB,CAACnB,KAAAA,CAAAA,CAAOoB,CAAC,EACxCC,2BAA4BrB,CAAAA,KAAAA,CAAAA,EAC5BkB,YAAaI,CAAAA,yBAAyB,CAACtB,KAAOgB,EAAAA,KAAAA,CAAAA,CAAAA;AAElD;AAEA;;;IAIO,SAASO,iBAAAA,CACdtB,SAAiB,EACjBD,KAA4B,EAC5BwB,CAAc,EACdT,MAAmB,EACnBU,MAAe,EAAA;IAEf,MAAMrB,EAAAA,GAAKJ,MAAMK,QAAQ;IACzB,MAAMqB,cAAAA,GAAiBR,YAAaC,CAAAA,kBAAkB,CAACnB,KAAAA,CAAAA;AACvD,IAAA,MAAM2B,qBAAqBN,2BAA4BrB,CAAAA,KAAAA,CAAAA;AACvD,IAAA,IAAIC,cAAc2B,sBAAwB,EAAA;AACxC,QAAA,OAAOxB,EAAGa,CAAAA,GAAG,CAACS,cAAAA,CAAeN,CAAC,EAAEO,kBAAAA,CAAAA;KAC3B,MAAA;AACL,QAAA,MAAME,OAAUX,GAAAA,YAAAA,CAAaY,qBAAqB,CAAC9B,OAAO+B,EAAE;AAC5D,QAAA,MAAM7B,cAAcuB,MAASD,GAAAA,CAAAA,GAAIN,aAAac,gCAAgC,CAAChC,OAAOwB,CAAGK,EAAAA,OAAAA,CAAAA;AACzF,QAAA,MAAMI,kBAAkBlC,qCACtBC,CAAAA,KAAAA,EACAC,SACAC,EAAAA,WAAAA,EACAwB,eAAeQ,CAAC,CAAA;AAElB,QAAA,IAAIC,OAAO/B,EAAGa,CAAAA,GAAG,CAACS,cAAeN,CAAAA,CAAC,EAAEO,kBAAoBM,EAAAA,eAAAA,CAAAA;QACxD,IAAIzB,8BAAAA,CAA+BR,OAAOC,SAAY,CAAA,EAAA;YACpD,MAAMK,WAAAA,GAAc,KAACN,CAAiEO,YAAY;AAClG4B,YAAAA,IAAAA,GAAO/B,EAAGa,CAAAA,GAAG,CAACkB,IAAAA,EAAM/B,EAAGS,CAAAA,GAAG,CAAC,IAAA,EAAM,IAAMT,EAAAA,EAAAA,CAAGM,KAAK,CAACJ,aAAa,CAAG,EAAA,CAAA,CAAA,CAAA,CAAA;AAClE;QACA,OAAO6B,IAAAA;AACT;AACF;;;;"}

package/dist/shadow/shadow_impl.js

@@ -41,6 +41,95 @@ import { getDevice } from '../app/api.js';
         const device = getDevice();
         return device.type !== 'webgl' || REVERSE_Z && device.getDeviceCaps().framebufferCaps.supportDepth32float ? 'd32f' : 'd24s8';
     }
+    /**
+   * Number of geometry passes this implementation needs over the shadow casters.
+   *
+   * Almost every technique rasterises the casters once and post-processes the
+   * result, which is what {@link postRenderShadowMap} is for - it runs after the
+   * geometry is on the map and receives no scene state, so a blur or resolve
+   * fits there but a second draw of the casters does not.
+   *
+   * Deep opacity maps do need that second draw: the first pass establishes the
+   * frontmost depth per texel and the second accumulates transmittance in layers
+   * measured from it, so the casters must be rasterised again with the first
+   * pass's output already available. Returning a count above one makes
+   * `ShadowMapper.render` repeat the draw, calling {@link beginGeometryPass}
+   * before each one.
+   *
+   * @returns The number of passes; one unless overridden.
+   */ getGeometryPassCount(_shadowMapParams) {
+        return 1;
+    }
+    /**
+   * Whether this implementation can split a directional light into cascades.
+   *
+   * Cascades need one shadow map per split, which every depth-based technique
+   * gets by rendering into array layers. A technique whose storage is already
+   * spoken for - a deep opacity map packs layer depth and coverage into the one
+   * texture the receiver is allowed to bind - has nowhere to put them, and asks
+   * to be driven with a single split instead.
+   *
+   * @returns True unless overridden.
+   */ supportsCascades() {
+        return true;
+    }
+    /**
+   * Prepares state for the given geometry pass.
+   *
+   * Only called when {@link getGeometryPassCount} returns more than one. The
+   * index is zero-based. Implementations that vary the emitted shader between
+   * passes must fold the index into {@link getShaderHash} as well, since the
+   * shadow pass keys its programs on that hash.
+   *
+   * @param shadowMapParams - Current shadow map state.
+   * @param pass - Zero-based index of the geometry pass about to run.
+   */ beginGeometryPass(_shadowMapParams, _pass) {}
+    /**
+   * Last say on the render states a shadow caster is drawn with.
+   *
+   * Runs after the material has set up its own states, in the same spirit as the
+   * OIT hook on the transparent pass. Techniques that rasterise the casters once
+   * want the defaults - depth test and write on, no blending - and leave this
+   * alone. An accumulating pass wants the opposite and overrides it here rather
+   * than teaching the material about shadow implementations.
+   *
+   * @param shadowMapParams - Current shadow map state.
+   * @param stateSet - The state set about to be applied, already populated.
+   */ setCasterRenderStates(_shadowMapParams, _stateSet) {}
+    /**
+   * Declares any extra resources the caster shader needs, in bind group 0.
+   *
+   * The shadow map pass otherwise gives a caster only the camera and the light,
+   * which is all a technique needs when it just records depth. One that reads
+   * back its own earlier output - a deep opacity map measuring layers from the
+   * frontmost strand - declares that input here instead of the pass hard-coding
+   * knowledge of the implementation.
+   *
+   * @param scope - Global shader scope of the caster program.
+   * @param shadowMapParams - Current shadow map state.
+   */ declareCasterUniforms(_scope, _shadowMapParams) {}
+    /**
+   * Binds whatever {@link declareCasterUniforms} declared.
+   *
+   * @param bindGroup - Bind group 0 of the caster program.
+   * @param shadowMapParams - Current shadow map state.
+   */ applyCasterUniforms(_bindGroup, _shadowMapParams) {}
+    /**
+   * Whether casters should still be alpha-clipped before their shadow output.
+   *
+   * A depth-recording technique wants the clip: a fragment that fails it is not
+   * there, and letting it write depth would block light with geometry the eye
+   * never sees. A technique that records coverage instead wants the raw alpha,
+   * because the clip destroys exactly the quantity it is accumulating - a
+   * dithered caster survives with probability alpha and then contributes alpha,
+   * which accumulates alpha squared, and a cutoff drops the thin strands that
+   * carry most of a groom's transmittance.
+   *
+   * @param shadowMapParams - Current shadow map state.
+   * @returns True unless overridden.
+   */ clipsCasterAlpha(_shadowMapParams) {
+        return true;
+    }
 }
 
 export { ShadowImpl, getPackedShadowMapClearColor, getShadowMapFarthestDepth };

package/dist/shadow/shadow_impl.js.map

@@ -1 +1 @@
-{"version":3,"file":"shadow_impl.js","sources":["../../src/shadow/shadow_impl.ts"],"sourcesContent":["import type { PBInsideFunctionScope, PBShaderExp, TextureFormat } from '@zephyr3d/device';\r\nimport type { ShadowMapParams, ShadowMapType, ShadowMode } from './shadowmapper';\r\nimport { REVERSE_Z, Vector4, type Nullable } from '@zephyr3d/base';\r\nimport { isDeviceDepthShadow } from '../shaders/shadow';\r\nimport { getDevice } from '../app/api';\r\n\r\n/** @internal */\r\nexport function getShadowMapFarthestDepth(lightType: number) {\r\n  return REVERSE_Z && isDeviceDepthShadow(lightType) ? 0 : 1;\r\n}\r\n\r\n/** @internal */\r\nexport function getPackedShadowMapClearColor(lightType: number) {\r\n  // The RGBA8 decoder assigns the alpha channel a weight of 1, so the\r\n  // normalized depth endpoints are represented by transparent/opaque black.\r\n  return new Vector4(0, 0, 0, getShadowMapFarthestDepth(lightType));\r\n}\r\n\r\n/** @internal */\r\nexport abstract class ShadowImpl {\r\n  protected _resourceDirty: boolean;\r\n  constructor() {\r\n    this._resourceDirty = true;\r\n  }\r\n  invalidateResource() {\r\n    this._resourceDirty = true;\r\n  }\r\n  updateResources(shadowMapParams: ShadowMapParams) {\r\n    this.doUpdateResources(shadowMapParams);\r\n  }\r\n  abstract getType(): ShadowMode;\r\n  abstract getShadowMapBorder(shadowMapParams: ShadowMapParams): number;\r\n  getShadowMapClearColor(shadowMapParams: ShadowMapParams) {\r\n    const colorAttachment = shadowMapParams.shadowMapFramebuffer?.getColorAttachments()[0];\r\n    // Empty texels must read as \"farthest\": under reverse-Z that is 0 for\r\n    // device-encoded directional/rect maps, 1 for linear point/spot maps.\r\n    const farthest = getShadowMapFarthestDepth(shadowMapParams.lightType);\r\n    return colorAttachment\r\n      ? colorAttachment.isFloatFormat()\r\n        ? new Vector4(farthest, farthest, farthest, 1)\r\n        : getPackedShadowMapClearColor(shadowMapParams.lightType)\r\n      : null;\r\n  }\r\n  /**\r\n   * Depth format for shadow maps rendered into a native depth attachment.\r\n   *\r\n   * Float depth everywhere except WebGL, where d24s8 is kept under\r\n   * standard-Z (WebGL1 compatibility, no precision benefit anyway). Under\r\n   * reverse-Z the WebGL2 float depth format is used so shadow maps share\r\n   * the near-uniform precision distribution (full benefit with\r\n   * EXT_clip_control active).\r\n   * @internal\r\n   */\r\n  protected preferredShadowMapDepthFormat(): TextureFormat {\r\n    const device = getDevice();\r\n    return device.type !== 'webgl' ||\r\n      (REVERSE_Z && device.getDeviceCaps().framebufferCaps.supportDepth32float)\r\n      ? 'd32f'\r\n      : 'd24s8';\r\n  }\r\n  abstract getParams(out?: Vector4): Vector4;\r\n  abstract getShadowMap(shadowMapParams: ShadowMapParams): ShadowMapType;\r\n  abstract postRenderShadowMap(shadowMapParams: ShadowMapParams): void;\r\n  abstract getDepthScale(): number;\r\n  abstract setDepthScale(val: number): void;\r\n  abstract resourceDirty(): boolean;\r\n  abstract doUpdateResources(shadowMapParams: ShadowMapParams): void;\r\n  abstract getShaderHash(): string;\r\n  abstract computeShadowMapDepth(\r\n    shadowMapParams: ShadowMapParams,\r\n    scope: PBInsideFunctionScope,\r\n    worldPos: PBShaderExp\r\n  ): PBShaderExp;\r\n  abstract computeShadow(\r\n    shadowMapParams: ShadowMapParams,\r\n    scope: PBInsideFunctionScope,\r\n    shadowVertex: PBShaderExp,\r\n    NdotL: PBShaderExp\r\n  ): PBShaderExp;\r\n  abstract computeShadowCSM(\r\n    shadowMapParams: ShadowMapParams,\r\n    scope: PBInsideFunctionScope,\r\n    shadowVertex: PBShaderExp,\r\n    NdotL: PBShaderExp,\r\n    split: PBShaderExp\r\n  ): PBShaderExp;\r\n  abstract getShadowMapColorFormat(shadowMapParams: ShadowMapParams): Nullable<TextureFormat>;\r\n  abstract getShadowMapDepthFormat(shadowMapParams: ShadowMapParams): TextureFormat;\r\n  abstract useNativeShadowMap(shadowMapParams: ShadowMapParams): boolean;\r\n}\r\n"],"names":["getShadowMapFarthestDepth","lightType","REVERSE_Z","isDeviceDepthShadow","getPackedShadowMapClearColor","Vector4","ShadowImpl","_resourceDirty","invalidateResource","updateResources","shadowMapParams","doUpdateResources","getShadowMapClearColor","colorAttachment","shadowMapFramebuffer","getColorAttachments","farthest","isFloatFormat","device","getDevice","type","getDeviceCaps","framebufferCaps","supportDepth32float"],"mappings":";;;;AAMA,iBACO,SAASA,yBAAAA,CAA0BC,SAAiB,EAAA;IACzD,OAAOC,SAAAA,IAAaC,mBAAoBF,CAAAA,SAAAA,CAAAA,GAAa,CAAI,GAAA,CAAA;AAC3D;AAEA,iBACO,SAASG,4BAAAA,CAA6BH,SAAiB,EAAA;;;AAG5D,IAAA,OAAO,IAAII,OAAAA,CAAQ,CAAG,EAAA,CAAA,EAAG,GAAGL,yBAA0BC,CAAAA,SAAAA,CAAAA,CAAAA;AACxD;AAEA,iBACO,MAAeK,UAAAA,CAAAA;IACVC,cAAwB;IAClC,WAAc,EAAA;QACZ,IAAI,CAACA,cAAc,GAAG,IAAA;AACxB;IACAC,kBAAqB,GAAA;QACnB,IAAI,CAACD,cAAc,GAAG,IAAA;AACxB;AACAE,IAAAA,eAAAA,CAAgBC,eAAgC,EAAE;QAChD,IAAI,CAACC,iBAAiB,CAACD,eAAAA,CAAAA;AACzB;AAGAE,IAAAA,sBAAAA,CAAuBF,eAAgC,EAAE;AACvD,QAAA,MAAMG,kBAAkBH,eAAgBI,CAAAA,oBAAoB,EAAEC,mBAAAA,EAAqB,CAAC,CAAE,CAAA;;;QAGtF,MAAMC,QAAAA,GAAWhB,yBAA0BU,CAAAA,eAAAA,CAAgBT,SAAS,CAAA;AACpE,QAAA,OAAOY,eACHA,GAAAA,eAAAA,CAAgBI,aAAa,EAAA,GAC3B,IAAIZ,OAAAA,CAAQW,QAAUA,EAAAA,QAAAA,EAAUA,QAAU,EAAA,CAAA,CAAA,GAC1CZ,4BAA6BM,CAAAA,eAAAA,CAAgBT,SAAS,CACxD,GAAA,IAAA;AACN;AACA;;;;;;;;;AASC,MACD,6BAAyD,GAAA;AACvD,QAAA,MAAMiB,MAASC,GAAAA,SAAAA,EAAAA;AACf,QAAA,OAAOD,MAAOE,CAAAA,IAAI,KAAK,OAAA,IACpBlB,SAAagB,IAAAA,MAAAA,CAAOG,aAAa,EAAA,CAAGC,eAAe,CAACC,mBAAmB,GACtE,MACA,GAAA,OAAA;AACN;AA8BF;;;;"}
+{"version":3,"file":"shadow_impl.js","sources":["../../src/shadow/shadow_impl.ts"],"sourcesContent":["import type {\r\n  BindGroup,\r\n  PBGlobalScope,\r\n  PBInsideFunctionScope,\r\n  PBShaderExp,\r\n  RenderStateSet,\r\n  TextureFormat\r\n} from '@zephyr3d/device';\r\nimport type { ShadowMapParams, ShadowMapType, ShadowMode } from './shadowmapper';\r\nimport { REVERSE_Z, Vector4, type Nullable } from '@zephyr3d/base';\r\nimport { isDeviceDepthShadow } from '../shaders/shadow';\r\nimport { getDevice } from '../app/api';\r\n\r\n/** @internal */\r\nexport function getShadowMapFarthestDepth(lightType: number) {\r\n  return REVERSE_Z && isDeviceDepthShadow(lightType) ? 0 : 1;\r\n}\r\n\r\n/** @internal */\r\nexport function getPackedShadowMapClearColor(lightType: number) {\r\n  // The RGBA8 decoder assigns the alpha channel a weight of 1, so the\r\n  // normalized depth endpoints are represented by transparent/opaque black.\r\n  return new Vector4(0, 0, 0, getShadowMapFarthestDepth(lightType));\r\n}\r\n\r\n/** @internal */\r\nexport abstract class ShadowImpl {\r\n  protected _resourceDirty: boolean;\r\n  constructor() {\r\n    this._resourceDirty = true;\r\n  }\r\n  invalidateResource() {\r\n    this._resourceDirty = true;\r\n  }\r\n  updateResources(shadowMapParams: ShadowMapParams) {\r\n    this.doUpdateResources(shadowMapParams);\r\n  }\r\n  abstract getType(): ShadowMode;\r\n  abstract getShadowMapBorder(shadowMapParams: ShadowMapParams): number;\r\n  getShadowMapClearColor(shadowMapParams: ShadowMapParams) {\r\n    const colorAttachment = shadowMapParams.shadowMapFramebuffer?.getColorAttachments()[0];\r\n    // Empty texels must read as \"farthest\": under reverse-Z that is 0 for\r\n    // device-encoded directional/rect maps, 1 for linear point/spot maps.\r\n    const farthest = getShadowMapFarthestDepth(shadowMapParams.lightType);\r\n    return colorAttachment\r\n      ? colorAttachment.isFloatFormat()\r\n        ? new Vector4(farthest, farthest, farthest, 1)\r\n        : getPackedShadowMapClearColor(shadowMapParams.lightType)\r\n      : null;\r\n  }\r\n  /**\r\n   * Depth format for shadow maps rendered into a native depth attachment.\r\n   *\r\n   * Float depth everywhere except WebGL, where d24s8 is kept under\r\n   * standard-Z (WebGL1 compatibility, no precision benefit anyway). Under\r\n   * reverse-Z the WebGL2 float depth format is used so shadow maps share\r\n   * the near-uniform precision distribution (full benefit with\r\n   * EXT_clip_control active).\r\n   * @internal\r\n   */\r\n  protected preferredShadowMapDepthFormat(): TextureFormat {\r\n    const device = getDevice();\r\n    return device.type !== 'webgl' ||\r\n      (REVERSE_Z && device.getDeviceCaps().framebufferCaps.supportDepth32float)\r\n      ? 'd32f'\r\n      : 'd24s8';\r\n  }\r\n  abstract getParams(out?: Vector4): Vector4;\r\n  /**\r\n   * Number of geometry passes this implementation needs over the shadow casters.\r\n   *\r\n   * Almost every technique rasterises the casters once and post-processes the\r\n   * result, which is what {@link postRenderShadowMap} is for - it runs after the\r\n   * geometry is on the map and receives no scene state, so a blur or resolve\r\n   * fits there but a second draw of the casters does not.\r\n   *\r\n   * Deep opacity maps do need that second draw: the first pass establishes the\r\n   * frontmost depth per texel and the second accumulates transmittance in layers\r\n   * measured from it, so the casters must be rasterised again with the first\r\n   * pass's output already available. Returning a count above one makes\r\n   * `ShadowMapper.render` repeat the draw, calling {@link beginGeometryPass}\r\n   * before each one.\r\n   *\r\n   * @returns The number of passes; one unless overridden.\r\n   */\r\n  getGeometryPassCount(_shadowMapParams: ShadowMapParams): number {\r\n    return 1;\r\n  }\r\n  /**\r\n   * Whether this implementation can split a directional light into cascades.\r\n   *\r\n   * Cascades need one shadow map per split, which every depth-based technique\r\n   * gets by rendering into array layers. A technique whose storage is already\r\n   * spoken for - a deep opacity map packs layer depth and coverage into the one\r\n   * texture the receiver is allowed to bind - has nowhere to put them, and asks\r\n   * to be driven with a single split instead.\r\n   *\r\n   * @returns True unless overridden.\r\n   */\r\n  supportsCascades(): boolean {\r\n    return true;\r\n  }\r\n  /**\r\n   * Prepares state for the given geometry pass.\r\n   *\r\n   * Only called when {@link getGeometryPassCount} returns more than one. The\r\n   * index is zero-based. Implementations that vary the emitted shader between\r\n   * passes must fold the index into {@link getShaderHash} as well, since the\r\n   * shadow pass keys its programs on that hash.\r\n   *\r\n   * @param shadowMapParams - Current shadow map state.\r\n   * @param pass - Zero-based index of the geometry pass about to run.\r\n   */\r\n  beginGeometryPass(_shadowMapParams: ShadowMapParams, _pass: number): void {}\r\n  /**\r\n   * Last say on the render states a shadow caster is drawn with.\r\n   *\r\n   * Runs after the material has set up its own states, in the same spirit as the\r\n   * OIT hook on the transparent pass. Techniques that rasterise the casters once\r\n   * want the defaults - depth test and write on, no blending - and leave this\r\n   * alone. An accumulating pass wants the opposite and overrides it here rather\r\n   * than teaching the material about shadow implementations.\r\n   *\r\n   * @param shadowMapParams - Current shadow map state.\r\n   * @param stateSet - The state set about to be applied, already populated.\r\n   */\r\n  setCasterRenderStates(_shadowMapParams: ShadowMapParams, _stateSet: RenderStateSet): void {}\r\n  /**\r\n   * Declares any extra resources the caster shader needs, in bind group 0.\r\n   *\r\n   * The shadow map pass otherwise gives a caster only the camera and the light,\r\n   * which is all a technique needs when it just records depth. One that reads\r\n   * back its own earlier output - a deep opacity map measuring layers from the\r\n   * frontmost strand - declares that input here instead of the pass hard-coding\r\n   * knowledge of the implementation.\r\n   *\r\n   * @param scope - Global shader scope of the caster program.\r\n   * @param shadowMapParams - Current shadow map state.\r\n   */\r\n  declareCasterUniforms(_scope: PBGlobalScope, _shadowMapParams: ShadowMapParams): void {}\r\n  /**\r\n   * Binds whatever {@link declareCasterUniforms} declared.\r\n   *\r\n   * @param bindGroup - Bind group 0 of the caster program.\r\n   * @param shadowMapParams - Current shadow map state.\r\n   */\r\n  applyCasterUniforms(_bindGroup: BindGroup, _shadowMapParams: ShadowMapParams): void {}\r\n  /**\r\n   * Whether casters should still be alpha-clipped before their shadow output.\r\n   *\r\n   * A depth-recording technique wants the clip: a fragment that fails it is not\r\n   * there, and letting it write depth would block light with geometry the eye\r\n   * never sees. A technique that records coverage instead wants the raw alpha,\r\n   * because the clip destroys exactly the quantity it is accumulating - a\r\n   * dithered caster survives with probability alpha and then contributes alpha,\r\n   * which accumulates alpha squared, and a cutoff drops the thin strands that\r\n   * carry most of a groom's transmittance.\r\n   *\r\n   * @param shadowMapParams - Current shadow map state.\r\n   * @returns True unless overridden.\r\n   */\r\n  clipsCasterAlpha(_shadowMapParams: ShadowMapParams): boolean {\r\n    return true;\r\n  }\r\n  abstract getShadowMap(shadowMapParams: ShadowMapParams): ShadowMapType;\r\n  abstract postRenderShadowMap(shadowMapParams: ShadowMapParams): void;\r\n  abstract getDepthScale(): number;\r\n  abstract setDepthScale(val: number): void;\r\n  abstract resourceDirty(): boolean;\r\n  abstract doUpdateResources(shadowMapParams: ShadowMapParams): void;\r\n  abstract getShaderHash(): string;\r\n  /**\r\n   * Fragment output for a shadow caster.\r\n   *\r\n   * @param shadowMapParams - Current shadow map state.\r\n   * @param scope - Caster fragment scope.\r\n   * @param worldPos - World position of the fragment.\r\n   * @param alpha - The material's own alpha, or null when it computes no fragment\r\n   * colour and the fragment is therefore fully opaque. Depth-recording techniques\r\n   * ignore it - by the time this runs the fragment has already survived whatever\r\n   * alpha test applies - but one that records absorption needs the value itself.\r\n   * It must be passed rather than read out of `scope`, because the caller's\r\n   * `outColor` is local to the material's own shader function and defaults to a\r\n   * zero vector when no colour was computed, which is indistinguishable from a\r\n   * genuinely transparent fragment.\r\n   */\r\n  abstract computeShadowMapDepth(\r\n    shadowMapParams: ShadowMapParams,\r\n    scope: PBInsideFunctionScope,\r\n    worldPos: PBShaderExp,\r\n    alpha: Nullable<PBShaderExp>\r\n  ): PBShaderExp;\r\n  abstract computeShadow(\r\n    shadowMapParams: ShadowMapParams,\r\n    scope: PBInsideFunctionScope,\r\n    shadowVertex: PBShaderExp,\r\n    NdotL: PBShaderExp\r\n  ): PBShaderExp;\r\n  abstract computeShadowCSM(\r\n    shadowMapParams: ShadowMapParams,\r\n    scope: PBInsideFunctionScope,\r\n    shadowVertex: PBShaderExp,\r\n    NdotL: PBShaderExp,\r\n    split: PBShaderExp\r\n  ): PBShaderExp;\r\n  abstract getShadowMapColorFormat(shadowMapParams: ShadowMapParams): Nullable<TextureFormat>;\r\n  abstract getShadowMapDepthFormat(shadowMapParams: ShadowMapParams): TextureFormat;\r\n  abstract useNativeShadowMap(shadowMapParams: ShadowMapParams): boolean;\r\n}\r\n"],"names":["getShadowMapFarthestDepth","lightType","REVERSE_Z","isDeviceDepthShadow","getPackedShadowMapClearColor","Vector4","ShadowImpl","_resourceDirty","invalidateResource","updateResources","shadowMapParams","doUpdateResources","getShadowMapClearColor","colorAttachment","shadowMapFramebuffer","getColorAttachments","farthest","isFloatFormat","device","getDevice","type","getDeviceCaps","framebufferCaps","supportDepth32float","getGeometryPassCount","_shadowMapParams","supportsCascades","beginGeometryPass","_pass","setCasterRenderStates","_stateSet","declareCasterUniforms","_scope","applyCasterUniforms","_bindGroup","clipsCasterAlpha"],"mappings":";;;;AAaA,iBACO,SAASA,yBAAAA,CAA0BC,SAAiB,EAAA;IACzD,OAAOC,SAAAA,IAAaC,mBAAoBF,CAAAA,SAAAA,CAAAA,GAAa,CAAI,GAAA,CAAA;AAC3D;AAEA,iBACO,SAASG,4BAAAA,CAA6BH,SAAiB,EAAA;;;AAG5D,IAAA,OAAO,IAAII,OAAAA,CAAQ,CAAG,EAAA,CAAA,EAAG,GAAGL,yBAA0BC,CAAAA,SAAAA,CAAAA,CAAAA;AACxD;AAEA,iBACO,MAAeK,UAAAA,CAAAA;IACVC,cAAwB;IAClC,WAAc,EAAA;QACZ,IAAI,CAACA,cAAc,GAAG,IAAA;AACxB;IACAC,kBAAqB,GAAA;QACnB,IAAI,CAACD,cAAc,GAAG,IAAA;AACxB;AACAE,IAAAA,eAAAA,CAAgBC,eAAgC,EAAE;QAChD,IAAI,CAACC,iBAAiB,CAACD,eAAAA,CAAAA;AACzB;AAGAE,IAAAA,sBAAAA,CAAuBF,eAAgC,EAAE;AACvD,QAAA,MAAMG,kBAAkBH,eAAgBI,CAAAA,oBAAoB,EAAEC,mBAAAA,EAAqB,CAAC,CAAE,CAAA;;;QAGtF,MAAMC,QAAAA,GAAWhB,yBAA0BU,CAAAA,eAAAA,CAAgBT,SAAS,CAAA;AACpE,QAAA,OAAOY,eACHA,GAAAA,eAAAA,CAAgBI,aAAa,EAAA,GAC3B,IAAIZ,OAAAA,CAAQW,QAAUA,EAAAA,QAAAA,EAAUA,QAAU,EAAA,CAAA,CAAA,GAC1CZ,4BAA6BM,CAAAA,eAAAA,CAAgBT,SAAS,CACxD,GAAA,IAAA;AACN;AACA;;;;;;;;;AASC,MACD,6BAAyD,GAAA;AACvD,QAAA,MAAMiB,MAASC,GAAAA,SAAAA,EAAAA;AACf,QAAA,OAAOD,MAAOE,CAAAA,IAAI,KAAK,OAAA,IACpBlB,SAAagB,IAAAA,MAAAA,CAAOG,aAAa,EAAA,CAAGC,eAAe,CAACC,mBAAmB,GACtE,MACA,GAAA,OAAA;AACN;AAEA;;;;;;;;;;;;;;;;MAiBAC,oBAAAA,CAAqBC,gBAAiC,EAAU;QAC9D,OAAO,CAAA;AACT;AACA;;;;;;;;;;AAUC,MACDC,gBAA4B,GAAA;QAC1B,OAAO,IAAA;AACT;AACA;;;;;;;;;;AAUC,MACDC,iBAAkBF,CAAAA,gBAAiC,EAAEG,KAAa,EAAQ;AAC1E;;;;;;;;;;;AAWC,MACDC,qBAAsBJ,CAAAA,gBAAiC,EAAEK,SAAyB,EAAQ;AAC1F;;;;;;;;;;;AAWC,MACDC,qBAAsBC,CAAAA,MAAqB,EAAEP,gBAAiC,EAAQ;AACtF;;;;;AAKC,MACDQ,mBAAoBC,CAAAA,UAAqB,EAAET,gBAAiC,EAAQ;AACpF;;;;;;;;;;;;;MAcAU,gBAAAA,CAAiBV,gBAAiC,EAAW;QAC3D,OAAO,IAAA;AACT;AA6CF;;;;"}

package/dist/shadow/shadow_region.js

@@ -170,7 +170,7 @@ import { Disposable, AABB, DWeakRef } from '@zephyr3d/base';
         return this._staticCasters.some((entry)=>entry.ref.get() === caster) || this._dynamicCasters.some((entry)=>entry.ref.get() === caster);
     }
     /** @internal */ isShadowCaster(caster) {
-        return !caster.disposed && (caster.isMesh() || caster.isClipmapTerrain());
+        return !caster.disposed && (caster.isMesh() || caster.isClipmapTerrain() || caster.isHair());
     }
     /** @internal */ getCasterAABB(caster) {
         const bbox = caster.getWorldBoundingVolume()?.toAABB();

package/dist/shadow/shadow_region.js.map

@@ -1 +1 @@
-{"version":3,"file":"shadow_region.js","sources":["../../src/shadow/shadow_region.ts"],"sourcesContent":["import type { Nullable } from '@zephyr3d/base';\r\nimport { AABB, Disposable, DWeakRef } from '@zephyr3d/base';\r\nimport type { SceneNode } from '../scene/scene_node';\r\n\r\ntype StaticShadowCasterEntry = {\r\n  ref: DWeakRef<SceneNode>;\r\n  aabb: AABB;\r\n};\r\n\r\ntype DynamicShadowCasterEntry = {\r\n  ref: DWeakRef<SceneNode>;\r\n  callback: (node: SceneNode) => void;\r\n};\r\n\r\n/**\r\n * Maintains the world-space region used by directional light shadow maps.\r\n *\r\n * @public\r\n */\r\nexport class ShadowRegion extends Disposable {\r\n  /** @internal */\r\n  private _manualRegion: Nullable<AABB>;\r\n  /** @internal */\r\n  private readonly _staticRegion: AABB;\r\n  /** @internal */\r\n  private readonly _dynamicRegion: AABB;\r\n  /** @internal */\r\n  private readonly _region: AABB;\r\n  /** @internal */\r\n  private readonly _staticCasters: StaticShadowCasterEntry[];\r\n  /** @internal */\r\n  private readonly _dynamicCasters: DynamicShadowCasterEntry[];\r\n\r\n  /**\r\n   * Creates a shadow region.\r\n   *\r\n   * @param region - Optional manual world-space AABB used to initialize the region.\r\n   */\r\n  constructor(region?: Nullable<AABB>) {\r\n    super();\r\n    this._manualRegion = region ? new AABB(region) : null;\r\n    this._staticRegion = new AABB().beginExtend();\r\n    this._dynamicRegion = new AABB().beginExtend();\r\n    this._region = new AABB().beginExtend();\r\n    this._staticCasters = [];\r\n    this._dynamicCasters = [];\r\n    this.updateRegion();\r\n  }\r\n\r\n  /**\r\n   * Final world-space shadow region.\r\n   *\r\n   * @returns The union of the manual, static caster, and dynamic caster regions, or `null` if no valid region exists.\r\n   */\r\n  get region(): Nullable<AABB> {\r\n    return this._region.isValid() ? this._region : null;\r\n  }\r\n\r\n  /**\r\n   * Region contributed by manually assigned AABB.\r\n   *\r\n   * @returns The manually assigned region, or `null` if no manual region is set.\r\n   */\r\n  get manualRegion(): Nullable<AABB> {\r\n    return this._manualRegion;\r\n  }\r\n\r\n  /**\r\n   * Region contributed by static shadow casters.\r\n   *\r\n   * @returns The combined static caster region, or `null` if no valid static caster region exists.\r\n   */\r\n  get staticRegion(): Nullable<AABB> {\r\n    return this._staticRegion.isValid() ? this._staticRegion : null;\r\n  }\r\n\r\n  /**\r\n   * Region contributed by dynamic shadow casters.\r\n   *\r\n   * @returns The combined dynamic caster region, or `null` if no valid dynamic caster region exists.\r\n   */\r\n  get dynamicRegion(): Nullable<AABB> {\r\n    return this._dynamicRegion.isValid() ? this._dynamicRegion : null;\r\n  }\r\n\r\n  /**\r\n   * Assigns a manual world-space AABB to the region.\r\n   *\r\n   * @param region - The manual world-space AABB to use, or `null` to clear the manual region.\r\n   */\r\n  setRegion(region: Nullable<AABB>) {\r\n    this._manualRegion = region ? new AABB(region) : null;\r\n    this.updateRegion();\r\n  }\r\n\r\n  /**\r\n   * Adds a static shadow caster using a snapshot of its current world-space AABB.\r\n   *\r\n   * @param caster - The mesh or clipmap terrain node to include as a static caster.\r\n   * @returns `this` for chaining.\r\n   */\r\n  addStaticCaster(caster: SceneNode): this {\r\n    if (!this.isShadowCaster(caster) || this.hasCaster(caster)) {\r\n      return this;\r\n    }\r\n    const aabb = this.getCasterAABB(caster);\r\n    if (!aabb) {\r\n      return this;\r\n    }\r\n    this._staticCasters.push({\r\n      ref: new DWeakRef(caster),\r\n      aabb\r\n    });\r\n    this.extendRegion(this._staticRegion, aabb);\r\n    this.updateRegion();\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Adds a dynamic shadow caster and tracks its bounding volume changes.\r\n   *\r\n   * @param caster - The mesh or clipmap terrain node to include as a dynamic caster.\r\n   * @returns `this` for chaining.\r\n   */\r\n  addDynamicCaster(caster: SceneNode): this {\r\n    if (!this.isShadowCaster(caster) || this.hasCaster(caster)) {\r\n      return this;\r\n    }\r\n    const callback = () => {\r\n      this.rebuildDynamicRegion();\r\n    };\r\n    caster.on('bvchanged', callback);\r\n    this._dynamicCasters.push({\r\n      ref: new DWeakRef(caster),\r\n      callback\r\n    });\r\n    const aabb = this.getCasterAABB(caster);\r\n    if (aabb) {\r\n      this.extendRegion(this._dynamicRegion, aabb);\r\n      this.updateRegion();\r\n    }\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Removes a previously added shadow caster.\r\n   *\r\n   * @param caster - The caster node to remove from the static or dynamic caster list.\r\n   * @returns `this` for chaining.\r\n   */\r\n  removeCaster(caster: SceneNode): this {\r\n    let removed = false;\r\n    let changed = false;\r\n    for (let i = this._staticCasters.length - 1; i >= 0; i--) {\r\n      const entry = this._staticCasters[i];\r\n      const node = entry.ref.get();\r\n      if (!node || node === caster) {\r\n        entry.ref.dispose();\r\n        this._staticCasters.splice(i, 1);\r\n        changed = true;\r\n        removed ||= node === caster;\r\n      }\r\n    }\r\n    for (let i = this._dynamicCasters.length - 1; i >= 0; i--) {\r\n      const entry = this._dynamicCasters[i];\r\n      const node = entry.ref.get();\r\n      if (!node || node === caster) {\r\n        (node ?? caster).off('bvchanged', entry.callback);\r\n        entry.ref.dispose();\r\n        this._dynamicCasters.splice(i, 1);\r\n        changed = true;\r\n        removed ||= node === caster;\r\n      }\r\n    }\r\n    if (changed) {\r\n      this.rebuildStaticRegion();\r\n      this.rebuildDynamicRegion();\r\n    }\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Removes all shadow casters while keeping the manual region.\r\n   */\r\n  clearCasters() {\r\n    for (const entry of this._dynamicCasters) {\r\n      entry.ref.get()?.off('bvchanged', entry.callback);\r\n      entry.ref.dispose();\r\n    }\r\n    for (const entry of this._staticCasters) {\r\n      entry.ref.dispose();\r\n    }\r\n    this._staticCasters.length = 0;\r\n    this._dynamicCasters.length = 0;\r\n    this._staticRegion.beginExtend();\r\n    this._dynamicRegion.beginExtend();\r\n    this.updateRegion();\r\n  }\r\n\r\n  /**\r\n   * Clears the manual region and all shadow casters.\r\n   *\r\n   * @returns `this` for chaining.\r\n   */\r\n  clear(): this {\r\n    this._manualRegion = null;\r\n    this.clearCasters();\r\n    return this;\r\n  }\r\n\r\n  /** {@inheritDoc Disposable.onDispose} */\r\n  protected onDispose(): void {\r\n    this.clear();\r\n  }\r\n\r\n  /** @internal */\r\n  private hasCaster(caster: SceneNode): boolean {\r\n    return (\r\n      this._staticCasters.some((entry) => entry.ref.get() === caster) ||\r\n      this._dynamicCasters.some((entry) => entry.ref.get() === caster)\r\n    );\r\n  }\r\n\r\n  /** @internal */\r\n  private isShadowCaster(caster: SceneNode): boolean {\r\n    return !caster.disposed && (caster.isMesh() || caster.isClipmapTerrain());\r\n  }\r\n\r\n  /** @internal */\r\n  private getCasterAABB(caster: SceneNode): Nullable<AABB> {\r\n    const bbox = caster.getWorldBoundingVolume()?.toAABB();\r\n    return bbox?.isValid() ? new AABB(bbox) : null;\r\n  }\r\n\r\n  /** @internal */\r\n  private rebuildStaticRegion() {\r\n    this._staticRegion.beginExtend();\r\n    for (let i = this._staticCasters.length - 1; i >= 0; i--) {\r\n      const entry = this._staticCasters[i];\r\n      if (!entry.ref.get()) {\r\n        entry.ref.dispose();\r\n        this._staticCasters.splice(i, 1);\r\n      } else {\r\n        this.extendRegion(this._staticRegion, entry.aabb);\r\n      }\r\n    }\r\n    this.updateRegion();\r\n  }\r\n\r\n  /** @internal */\r\n  private rebuildDynamicRegion() {\r\n    this._dynamicRegion.beginExtend();\r\n    for (let i = this._dynamicCasters.length - 1; i >= 0; i--) {\r\n      const entry = this._dynamicCasters[i];\r\n      const caster = entry.ref.get();\r\n      if (!caster || !this.isShadowCaster(caster)) {\r\n        caster?.off('bvchanged', entry.callback);\r\n        entry.ref.dispose();\r\n        this._dynamicCasters.splice(i, 1);\r\n        continue;\r\n      }\r\n      const aabb = this.getCasterAABB(caster);\r\n      if (aabb) {\r\n        this.extendRegion(this._dynamicRegion, aabb);\r\n      }\r\n    }\r\n    this.updateRegion();\r\n  }\r\n\r\n  /** @internal */\r\n  private updateRegion() {\r\n    this._region.beginExtend();\r\n    if (this._manualRegion?.isValid()) {\r\n      this.extendRegion(this._region, this._manualRegion);\r\n    }\r\n    if (this._staticRegion.isValid()) {\r\n      this.extendRegion(this._region, this._staticRegion);\r\n    }\r\n    if (this._dynamicRegion.isValid()) {\r\n      this.extendRegion(this._region, this._dynamicRegion);\r\n    }\r\n  }\r\n\r\n  /** @internal */\r\n  private extendRegion(region: AABB, aabb: AABB) {\r\n    region.extend(aabb.minPoint);\r\n    region.extend(aabb.maxPoint);\r\n  }\r\n}\r\n"],"names":["ShadowRegion","Disposable","region","_manualRegion","AABB","_staticRegion","beginExtend","_dynamicRegion","_region","_staticCasters","_dynamicCasters","updateRegion","isValid","manualRegion","staticRegion","dynamicRegion","setRegion","addStaticCaster","caster","isShadowCaster","hasCaster","aabb","getCasterAABB","push","ref","DWeakRef","extendRegion","addDynamicCaster","callback","rebuildDynamicRegion","on","removeCaster","changed","i","length","entry","node","get","dispose","splice","off","rebuildStaticRegion","clearCasters","clear","some","disposed","isMesh","isClipmapTerrain","bbox","getWorldBoundingVolume","toAABB","extend","minPoint","maxPoint"],"mappings":"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"}
+{"version":3,"file":"shadow_region.js","sources":["../../src/shadow/shadow_region.ts"],"sourcesContent":["import type { Nullable } from '@zephyr3d/base';\r\nimport { AABB, Disposable, DWeakRef } from '@zephyr3d/base';\r\nimport type { SceneNode } from '../scene/scene_node';\r\n\r\ntype StaticShadowCasterEntry = {\r\n  ref: DWeakRef<SceneNode>;\r\n  aabb: AABB;\r\n};\r\n\r\ntype DynamicShadowCasterEntry = {\r\n  ref: DWeakRef<SceneNode>;\r\n  callback: (node: SceneNode) => void;\r\n};\r\n\r\n/**\r\n * Maintains the world-space region used by directional light shadow maps.\r\n *\r\n * @public\r\n */\r\nexport class ShadowRegion extends Disposable {\r\n  /** @internal */\r\n  private _manualRegion: Nullable<AABB>;\r\n  /** @internal */\r\n  private readonly _staticRegion: AABB;\r\n  /** @internal */\r\n  private readonly _dynamicRegion: AABB;\r\n  /** @internal */\r\n  private readonly _region: AABB;\r\n  /** @internal */\r\n  private readonly _staticCasters: StaticShadowCasterEntry[];\r\n  /** @internal */\r\n  private readonly _dynamicCasters: DynamicShadowCasterEntry[];\r\n\r\n  /**\r\n   * Creates a shadow region.\r\n   *\r\n   * @param region - Optional manual world-space AABB used to initialize the region.\r\n   */\r\n  constructor(region?: Nullable<AABB>) {\r\n    super();\r\n    this._manualRegion = region ? new AABB(region) : null;\r\n    this._staticRegion = new AABB().beginExtend();\r\n    this._dynamicRegion = new AABB().beginExtend();\r\n    this._region = new AABB().beginExtend();\r\n    this._staticCasters = [];\r\n    this._dynamicCasters = [];\r\n    this.updateRegion();\r\n  }\r\n\r\n  /**\r\n   * Final world-space shadow region.\r\n   *\r\n   * @returns The union of the manual, static caster, and dynamic caster regions, or `null` if no valid region exists.\r\n   */\r\n  get region(): Nullable<AABB> {\r\n    return this._region.isValid() ? this._region : null;\r\n  }\r\n\r\n  /**\r\n   * Region contributed by manually assigned AABB.\r\n   *\r\n   * @returns The manually assigned region, or `null` if no manual region is set.\r\n   */\r\n  get manualRegion(): Nullable<AABB> {\r\n    return this._manualRegion;\r\n  }\r\n\r\n  /**\r\n   * Region contributed by static shadow casters.\r\n   *\r\n   * @returns The combined static caster region, or `null` if no valid static caster region exists.\r\n   */\r\n  get staticRegion(): Nullable<AABB> {\r\n    return this._staticRegion.isValid() ? this._staticRegion : null;\r\n  }\r\n\r\n  /**\r\n   * Region contributed by dynamic shadow casters.\r\n   *\r\n   * @returns The combined dynamic caster region, or `null` if no valid dynamic caster region exists.\r\n   */\r\n  get dynamicRegion(): Nullable<AABB> {\r\n    return this._dynamicRegion.isValid() ? this._dynamicRegion : null;\r\n  }\r\n\r\n  /**\r\n   * Assigns a manual world-space AABB to the region.\r\n   *\r\n   * @param region - The manual world-space AABB to use, or `null` to clear the manual region.\r\n   */\r\n  setRegion(region: Nullable<AABB>) {\r\n    this._manualRegion = region ? new AABB(region) : null;\r\n    this.updateRegion();\r\n  }\r\n\r\n  /**\r\n   * Adds a static shadow caster using a snapshot of its current world-space AABB.\r\n   *\r\n   * @param caster - The mesh or clipmap terrain node to include as a static caster.\r\n   * @returns `this` for chaining.\r\n   */\r\n  addStaticCaster(caster: SceneNode): this {\r\n    if (!this.isShadowCaster(caster) || this.hasCaster(caster)) {\r\n      return this;\r\n    }\r\n    const aabb = this.getCasterAABB(caster);\r\n    if (!aabb) {\r\n      return this;\r\n    }\r\n    this._staticCasters.push({\r\n      ref: new DWeakRef(caster),\r\n      aabb\r\n    });\r\n    this.extendRegion(this._staticRegion, aabb);\r\n    this.updateRegion();\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Adds a dynamic shadow caster and tracks its bounding volume changes.\r\n   *\r\n   * @param caster - The mesh or clipmap terrain node to include as a dynamic caster.\r\n   * @returns `this` for chaining.\r\n   */\r\n  addDynamicCaster(caster: SceneNode): this {\r\n    if (!this.isShadowCaster(caster) || this.hasCaster(caster)) {\r\n      return this;\r\n    }\r\n    const callback = () => {\r\n      this.rebuildDynamicRegion();\r\n    };\r\n    caster.on('bvchanged', callback);\r\n    this._dynamicCasters.push({\r\n      ref: new DWeakRef(caster),\r\n      callback\r\n    });\r\n    const aabb = this.getCasterAABB(caster);\r\n    if (aabb) {\r\n      this.extendRegion(this._dynamicRegion, aabb);\r\n      this.updateRegion();\r\n    }\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Removes a previously added shadow caster.\r\n   *\r\n   * @param caster - The caster node to remove from the static or dynamic caster list.\r\n   * @returns `this` for chaining.\r\n   */\r\n  removeCaster(caster: SceneNode): this {\r\n    let removed = false;\r\n    let changed = false;\r\n    for (let i = this._staticCasters.length - 1; i >= 0; i--) {\r\n      const entry = this._staticCasters[i];\r\n      const node = entry.ref.get();\r\n      if (!node || node === caster) {\r\n        entry.ref.dispose();\r\n        this._staticCasters.splice(i, 1);\r\n        changed = true;\r\n        removed ||= node === caster;\r\n      }\r\n    }\r\n    for (let i = this._dynamicCasters.length - 1; i >= 0; i--) {\r\n      const entry = this._dynamicCasters[i];\r\n      const node = entry.ref.get();\r\n      if (!node || node === caster) {\r\n        (node ?? caster).off('bvchanged', entry.callback);\r\n        entry.ref.dispose();\r\n        this._dynamicCasters.splice(i, 1);\r\n        changed = true;\r\n        removed ||= node === caster;\r\n      }\r\n    }\r\n    if (changed) {\r\n      this.rebuildStaticRegion();\r\n      this.rebuildDynamicRegion();\r\n    }\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Removes all shadow casters while keeping the manual region.\r\n   */\r\n  clearCasters() {\r\n    for (const entry of this._dynamicCasters) {\r\n      entry.ref.get()?.off('bvchanged', entry.callback);\r\n      entry.ref.dispose();\r\n    }\r\n    for (const entry of this._staticCasters) {\r\n      entry.ref.dispose();\r\n    }\r\n    this._staticCasters.length = 0;\r\n    this._dynamicCasters.length = 0;\r\n    this._staticRegion.beginExtend();\r\n    this._dynamicRegion.beginExtend();\r\n    this.updateRegion();\r\n  }\r\n\r\n  /**\r\n   * Clears the manual region and all shadow casters.\r\n   *\r\n   * @returns `this` for chaining.\r\n   */\r\n  clear(): this {\r\n    this._manualRegion = null;\r\n    this.clearCasters();\r\n    return this;\r\n  }\r\n\r\n  /** {@inheritDoc Disposable.onDispose} */\r\n  protected onDispose(): void {\r\n    this.clear();\r\n  }\r\n\r\n  /** @internal */\r\n  private hasCaster(caster: SceneNode): boolean {\r\n    return (\r\n      this._staticCasters.some((entry) => entry.ref.get() === caster) ||\r\n      this._dynamicCasters.some((entry) => entry.ref.get() === caster)\r\n    );\r\n  }\r\n\r\n  /** @internal */\r\n  private isShadowCaster(caster: SceneNode): boolean {\r\n    return !caster.disposed && (caster.isMesh() || caster.isClipmapTerrain() || caster.isHair());\r\n  }\r\n\r\n  /** @internal */\r\n  private getCasterAABB(caster: SceneNode): Nullable<AABB> {\r\n    const bbox = caster.getWorldBoundingVolume()?.toAABB();\r\n    return bbox?.isValid() ? new AABB(bbox) : null;\r\n  }\r\n\r\n  /** @internal */\r\n  private rebuildStaticRegion() {\r\n    this._staticRegion.beginExtend();\r\n    for (let i = this._staticCasters.length - 1; i >= 0; i--) {\r\n      const entry = this._staticCasters[i];\r\n      if (!entry.ref.get()) {\r\n        entry.ref.dispose();\r\n        this._staticCasters.splice(i, 1);\r\n      } else {\r\n        this.extendRegion(this._staticRegion, entry.aabb);\r\n      }\r\n    }\r\n    this.updateRegion();\r\n  }\r\n\r\n  /** @internal */\r\n  private rebuildDynamicRegion() {\r\n    this._dynamicRegion.beginExtend();\r\n    for (let i = this._dynamicCasters.length - 1; i >= 0; i--) {\r\n      const entry = this._dynamicCasters[i];\r\n      const caster = entry.ref.get();\r\n      if (!caster || !this.isShadowCaster(caster)) {\r\n        caster?.off('bvchanged', entry.callback);\r\n        entry.ref.dispose();\r\n        this._dynamicCasters.splice(i, 1);\r\n        continue;\r\n      }\r\n      const aabb = this.getCasterAABB(caster);\r\n      if (aabb) {\r\n        this.extendRegion(this._dynamicRegion, aabb);\r\n      }\r\n    }\r\n    this.updateRegion();\r\n  }\r\n\r\n  /** @internal */\r\n  private updateRegion() {\r\n    this._region.beginExtend();\r\n    if (this._manualRegion?.isValid()) {\r\n      this.extendRegion(this._region, this._manualRegion);\r\n    }\r\n    if (this._staticRegion.isValid()) {\r\n      this.extendRegion(this._region, this._staticRegion);\r\n    }\r\n    if (this._dynamicRegion.isValid()) {\r\n      this.extendRegion(this._region, this._dynamicRegion);\r\n    }\r\n  }\r\n\r\n  /** @internal */\r\n  private extendRegion(region: AABB, aabb: AABB) {\r\n    region.extend(aabb.minPoint);\r\n    region.extend(aabb.maxPoint);\r\n  }\r\n}\r\n"],"names":["ShadowRegion","Disposable","region","_manualRegion","AABB","_staticRegion","beginExtend","_dynamicRegion","_region","_staticCasters","_dynamicCasters","updateRegion","isValid","manualRegion","staticRegion","dynamicRegion","setRegion","addStaticCaster","caster","isShadowCaster","hasCaster","aabb","getCasterAABB","push","ref","DWeakRef","extendRegion","addDynamicCaster","callback","rebuildDynamicRegion","on","removeCaster","changed","i","length","entry","node","get","dispose","splice","off","rebuildStaticRegion","clearCasters","clear","some","disposed","isMesh","isClipmapTerrain","isHair","bbox","getWorldBoundingVolume","toAABB","extend","minPoint","maxPoint"],"mappings":"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"}

package/dist/shadow/shadowmapper.js

@@ -5,8 +5,8 @@ import { ESM } from './esm.js';
 import { VSM } from './vsm.js';
 import { PCFOPT } from './pcf_opt.js';
 import { PCSS } from './pcss.js';
-import { LIGHT_TYPE_NONE, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_POINT } from '../values.js';
-import { ShaderHelper } from '../material/shader/helper.js';
+import { DOM } from './dom.js';
+import { LIGHT_TYPE_NONE, LIGHT_TYPE_POINT, LIGHT_TYPE_DIRECTIONAL } from '../values.js';
 import { getDevice } from '../app/api.js';
 import { ShadowRegion } from './shadow_region.js';
 
@@ -38,6 +38,9 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
     /** @internal */ _pcssFilterSampleCount;
     /** @internal */ _pcssMaxFilterRadius;
     /** @internal */ _pcssTemporalJitter;
+    /** @internal */ _domLayerDistance;
+    /** @internal */ _domDensity;
+    /** @internal */ _domFilterSize;
     /** @internal */ _vsmBlurKernelSize;
     /** @internal */ _vsmBlurRadius;
     /** @internal */ _vsmDarkness;
@@ -59,7 +62,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             numCascades: 1,
             splitLambda: 0.5,
             depthBias: 0.003,
-            normalBias: 0.2,
+            normalBias: 1.5,
             nearClip: 1
         };
         this._resourceDirty = true;
@@ -74,6 +77,9 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
         this._pcssFilterSampleCount = 32;
         this._pcssMaxFilterRadius = 32;
         this._pcssTemporalJitter = true;
+        this._domLayerDistance = 0.25;
+        this._domDensity = 1;
+        this._domFilterSize = 5;
         this._vsmBlurKernelSize = 5;
         this._vsmBlurRadius = 4;
         this._vsmDarkness = 0.3;
@@ -174,7 +180,20 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
     set depthBias(val) {
         this._config.depthBias = val;
     }
-    /** Normal bias for the shadow map */ get normalBias() {
+    /**
+   * Normal offset bias, in shadow map texels.
+   *
+   * @remarks
+   * Before sampling, the receiver is moved along its normal by this many texel
+   * widths, scaled by `sin(theta)` between the normal and the light so the
+   * offset is zero facing the light and largest at grazing incidence. This is
+   * what removes grazing-angle self-shadowing acne; {@link depthBias} alone
+   * cannot, because the depth error over one texel grows without bound as the
+   * surface turns away from the light.
+   *
+   * Useful values are roughly 1 to 4. Too little leaves acne on curved surfaces
+   * near the terminator; too much detaches contact shadows from thin geometry.
+   */ get normalBias() {
         return this._config.normalBias;
     }
     set normalBias(val) {
@@ -215,7 +234,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             this.shadowDistance = 120;
             this.splitLambda = 0.75;
             this.depthBias = 0.005;
-            this.normalBias = 0.3;
+            this.normalBias = 2;
             this.nearClip = 0.2;
             this.pcfKernelSize = 5;
             this.numShadowCascades = this._light.isDirectionLight() ? 3 : 1;
@@ -226,7 +245,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
         this.shadowDistance = 800;
         this.splitLambda = 0.6;
         this.depthBias = 0.0035;
-        this.normalBias = 0.22;
+        this.normalBias = 1.5;
         this.nearClip = 1;
         this.pcfKernelSize = 3;
         this.numShadowCascades = this._light.isDirectionLight() ? 4 : 1;
@@ -283,6 +302,69 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             }
         }
     }
+    /**
+   * Depth spanned by the deep opacity map's layers, in world units along the
+   * light direction. Only meaningful when the shadow mode is `dom`.
+   *
+   * @remarks
+   * Set it to roughly the thickness of the hair. Too small and everything past
+   * the outer strands saturates the last layer, which is a hard shadow again;
+   * too large and all three layers fall inside the first strand, leaving the
+   * interior unshadowed.
+   */ get domLayerDistance() {
+        return this._domLayerDistance;
+    }
+    set domLayerDistance(val) {
+        val = Math.max(0.0001, Number(val) || 0);
+        if (val !== this._domLayerDistance) {
+            this._domLayerDistance = val;
+            const dom = this.asDOM();
+            if (dom) {
+                dom.layerDistance = this._domLayerDistance;
+            }
+        }
+    }
+    /**
+   * How strongly accumulated hair coverage attenuates light. Only meaningful when
+   * the shadow mode is `dom`.
+   *
+   * @remarks
+   * Raise it to darken the interior of a groom without moving the layers.
+   */ get domDensity() {
+        return this._domDensity;
+    }
+    set domDensity(val) {
+        val = Math.max(0, Number(val) || 0);
+        if (val !== this._domDensity) {
+            this._domDensity = val;
+            const dom = this.asDOM();
+            if (dom) {
+                dom.density = this._domDensity;
+            }
+        }
+    }
+    /**
+   * Width of the deep opacity map's sampling kernel in texels: 1, 3, 5 or 7. Only
+   * meaningful when the shadow mode is `dom`.
+   *
+   * @remarks
+   * The technique's own gradation runs along the light rather than across the
+   * map, so without a kernel the silhouette of a groom is as hard an edge as an
+   * unfiltered shadow map gives. This is what softens it, at one layer lookup per
+   * tap. Defaults to 5.
+   */ get domFilterSize() {
+        return this._domFilterSize;
+    }
+    set domFilterSize(val) {
+        val = val !== 1 && val !== 3 && val !== 5 && val !== 7 ? 5 : val;
+        if (val !== this._domFilterSize) {
+            this._domFilterSize = val;
+            const dom = this.asDOM();
+            if (dom) {
+                dom.filterSize = this._domFilterSize;
+            }
+        }
+    }
     /** Blocker search sample count for PCSS shadow */ get pcssBlockerSampleCount() {
         return this._pcssBlockerSampleCount;
     }
@@ -456,25 +538,6 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             ctx.shadowMapInfo = null;
         }
     }
-    /** @internal */ static computeShadowBias(shadowMapParams, scope, z, NdotL, linear) {
-        const pb = scope.$builder;
-        const depthBiasParam = ShaderHelper.getDepthBiasValues(scope);
-        if (shadowMapParams.lightType === LIGHT_TYPE_DIRECTIONAL) {
-            return pb.dot(pb.mul(depthBiasParam.xy, pb.vec2(1, pb.sub(1, NdotL))), pb.vec2(1, 1));
-        } else {
-            const nearFar = ShaderHelper.getShadowCameraParams(scope).xy;
-            const linearDepth = linear ? z : ShaderHelper.nonLinearDepthToLinearNormalized(scope, z, nearFar);
-            const biasScaleFactor = pb.mix(1, depthBiasParam.w, linearDepth);
-            return pb.dot(pb.mul(depthBiasParam.xy, pb.vec2(1, pb.sub(1, NdotL)), biasScaleFactor), pb.vec2(1, 1));
-        }
-    }
-    /** @internal */ static computeShadowBiasCSM(shadowMapParams, scope, NdotL, split) {
-        const pb = scope.$builder;
-        const depthBiasParam = ShaderHelper.getDepthBiasValues(scope);
-        const splitFlags = pb.vec4(pb.float(pb.equal(split, 0)), pb.float(pb.equal(split, 1)), pb.float(pb.equal(split, 2)), pb.float(pb.equal(split, 3)));
-        const depthBiasScale = pb.dot(ShaderHelper.getDepthBiasScales(scope), splitFlags);
-        return pb.dot(pb.mul(depthBiasParam.xy, pb.vec2(1, pb.sub(1, NdotL)), depthBiasScale), pb.vec2(1, 1));
-    }
     /** @internal */ isTextureInvalid(texture, target, format, width, height) {
         return texture && (texture.target !== target || texture.format !== format || texture.width !== width || texture.height !== height || texture.depth !== this.numShadowCascades);
     }
@@ -766,8 +829,15 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
     /** @internal */ calcDepthBiasParams(camera, shadowMapSize, depthBias, normalBias, depthScale, result) {
         const sizeNear = Math.min(camera.getProjectionMatrix().getNearPlaneWidth(), camera.getProjectionMatrix().getNearPlaneHeight());
         const sizeFar = Math.min(camera.getProjectionMatrix().getFarPlaneWidth(), camera.getProjectionMatrix().getFarPlaneHeight());
-        const scaleFactor = sizeNear / shadowMapSize * 2;
-        result.setXYZW(depthBias * scaleFactor, normalBias * 0.0001, depthScale, sizeFar / sizeNear);
+        // World-space size of one shadow map texel at the near plane. Both bias
+        // terms are expressed in multiples of it, so a tighter cascade automatically
+        // gets a proportionally smaller offset.
+        const texelWorldSize = sizeNear / shadowMapSize;
+        result.setXYZW(depthBias * texelWorldSize * 2, // Normal offset distance in world units. Unlike a depth bias this moves
+        // the receiver sideways out of the texel that produces grazing-angle
+        // acne, which no amount of depth bias can fix (the required depth offset
+        // diverges as NdotL approaches zero).
+        normalBias * texelWorldSize, depthScale, sizeFar / sizeNear);
     }
     /** @internal */ postRenderShadowMap(shadowMapParams) {
         this._impl.postRenderShadowMap(shadowMapParams);
@@ -779,7 +849,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
         const shadowMapParams = ShadowMapper.fetchShadowMapParams();
         shadowMapParams.impl = this._impl;
         shadowMapParams.lightType = this.light.lightType;
-        shadowMapParams.numShadowCascades = shadowMapParams.lightType === LIGHT_TYPE_DIRECTIONAL ? this._config.numCascades ?? 1 : 1;
+        shadowMapParams.numShadowCascades = shadowMapParams.lightType === LIGHT_TYPE_DIRECTIONAL && this._impl.supportsCascades() ? this._config.numCascades ?? 1 : 1;
         ctx.shadowMapInfo.set(this.light, shadowMapParams);
         const scene = ctx.scene;
         const camera = ctx.camera;
@@ -791,6 +861,32 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
         shadowMapParams.depthClampEnabled = false;
         renderPass.clearColor = this._impl.getShadowMapClearColor(shadowMapParams);
         const depthScale = this._impl.getDepthScale();
+        const geometryPassCount = Math.max(1, this._impl.getGeometryPassCount(shadowMapParams) >> 0);
+        // Repeats the caster draw for implementations that need more than one look at
+        // the geometry (deep opacity maps). Single-pass implementations - every one
+        // but DOM - take the `pass === 0` path once and behave exactly as before.
+        const renderGeometry = (renderCamera, cullCamera)=>{
+            if (geometryPassCount === 1) {
+                renderPass.render(ctx, renderCamera, cullCamera);
+                return;
+            }
+            // Culling depends only on the camera, so the extra passes reuse the first
+            // pass's queue rather than walking the scene graph again per pass.
+            const renderQueue = renderPass.cullScene(ctx, cullCamera ?? renderCamera);
+            try {
+                for(let pass = 0; pass < geometryPassCount; pass++){
+                    this._impl.beginGeometryPass(shadowMapParams, pass);
+                    // The emitted caster shader differs between passes, and the shadow pass
+                    // keys its programs on this hash, so it has to be refreshed per pass
+                    // rather than computed once up front.
+                    shadowMapParams.shaderHash = this.getShaderHash(shadowMapParams);
+                    renderPass.clearColor = this._impl.getShadowMapClearColor(shadowMapParams);
+                    renderPass.render(ctx, renderCamera, cullCamera, renderQueue);
+                }
+            } finally{
+                renderQueue.dispose();
+            }
+        };
         const directionalShadowRegion = this._shadowRegion.region;
         const shadowRegion = this._light.isDirectionLight() && directionalShadowRegion?.isValid() ? directionalShadowRegion : scene.boundingBox;
         if (this._light.isPointLight()) {
@@ -811,20 +907,24 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
                 shadowMapRenderCamera.lookAtCubeFace(face);
                 fb.setColorAttachmentCubeFace(0, face);
                 fb.setDepthAttachmentCubeFace(face);
-                renderPass.render(ctx, shadowMapRenderCamera);
+                renderGeometry(shadowMapRenderCamera);
             }
             shadowMapParams.shadowMatrices.set(Matrix4x4.identity());
             ShadowMapper.releaseCamera(shadowMapRenderCamera);
         } else {
-            if (this._config.numCascades > 1) {
-                const distances = this.calcSplitDistances(camera.getNearPlane(), Math.min(this._shadowDistance, camera.getFarPlane()), this._config.numCascades);
+            // Reads the resolved count, not the configured one: an implementation that
+            // cannot store cascades has already collapsed it to a single split, and the
+            // cascade path would index array layers its shadow map does not have.
+            const numCascades = shadowMapParams.numShadowCascades;
+            if (numCascades > 1) {
+                const distances = this.calcSplitDistances(camera.getNearPlane(), Math.min(this._shadowDistance, camera.getFarPlane()), numCascades);
                 const cascadeCamera = ShadowMapper.fetchCameraForScene(scene);
                 const shadowMapRenderCamera = ShadowMapper.fetchCameraForScene(scene);
                 const shadowMapCullCamera = ShadowMapper.fetchCameraForScene(scene);
                 shadowMapCullCamera.clipMask = AABB.ClipLeft | AABB.ClipRight | AABB.ClipBottom | AABB.ClipTop;
                 cascadeCamera.parent = camera;
                 shadowMapParams.depthClampEnabled = getDevice().getDeviceCaps().shaderCaps.supportFragmentDepth;
-                for(let split = 0; split < this._config.numCascades; split++){
+                for(let split = 0; split < numCascades; split++){
                     cascadeCamera.setPerspective(camera.getFOV(), camera.getAspect(), distances[split], distances[split + 1]);
                     const snapMatrix = ShadowMapper._snapMatrix;
                     const border = shadowMapParams.impl.getShadowMapBorder(shadowMapParams); //20 / this._config.shadowMapSize;
@@ -839,8 +939,8 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
                         fb.setColorAttachmentLayer(0, split);
                         fb.setDepthAttachmentLayer(split);
                     } else {
-                        const numRows = this._config.numCascades > 2 ? 2 : 1;
-                        const numCols = this._config.numCascades > 1 ? 2 : 1;
+                        const numRows = numCascades > 2 ? 2 : 1;
+                        const numCols = numCascades > 1 ? 2 : 1;
                         const adjMatrix = new Matrix4x4();
                         const col = split % 2;
                         const row = split >> 1;
@@ -867,7 +967,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
                     }
                     device.setFramebuffer(fb);
                     device.setScissor(scissor);
-                    renderPass.render(ctx, shadowMapRenderCamera, shadowMapCullCamera);
+                    renderGeometry(shadowMapRenderCamera, shadowMapCullCamera);
                     shadowMapParams.shadowMatrices.set(Matrix4x4.transpose(shadowMapRenderCamera.viewProjectionMatrix), split * 16);
                     shadowMapParams.cascadeDistances[split] = distances[split + 1];
                 }
@@ -890,7 +990,7 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
                 shadowMapParams.cameraParams.setXYZW(shadowMapRenderCamera.getNearPlane(), shadowMapRenderCamera.getFarPlane(), this._config.shadowMapSize, this._shadowDistance);
                 device.setFramebuffer(fb);
                 shadowMapRenderCamera.setProjectionMatrix(Matrix4x4.multiply(snapMatrix, shadowMapRenderCamera.getProjectionMatrix()));
-                renderPass.render(ctx, shadowMapRenderCamera);
+                renderGeometry(shadowMapRenderCamera);
                 shadowMapParams.shadowMatrices.set(Matrix4x4.transpose(shadowMapRenderCamera.viewProjectionMatrix));
                 ShadowMapper.releaseCamera(shadowMapRenderCamera);
             }
@@ -898,10 +998,18 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
         this.postRenderShadowMap(shadowMapParams);
     }
     /** @internal */ applyMode(mode) {
-        if (mode !== 'hard' && mode !== 'vsm' && mode !== 'esm' && mode !== 'pcf' && mode !== 'pcf-pd' && mode !== 'pcf-opt' && mode !== 'pcss') {
+        if (mode !== 'hard' && mode !== 'vsm' && mode !== 'esm' && mode !== 'pcf' && mode !== 'pcf-pd' && mode !== 'pcf-opt' && mode !== 'pcss' && mode !== 'dom') {
             console.error(`ShadowMapper.setShadowMode() failed: invalid mode: ${mode}`);
             return;
         }
+        if (mode === 'dom' && getDevice().type !== 'webgpu') {
+            // The strand geometry this mode exists to shadow is WebGPU only, so the
+            // WebGL paths were never built. Falling back keeps a scene authored with it
+            // renderable rather than failing to produce a shadow map at all.
+            console.warn(`ShadowMapper.setShadowMode(): 'dom' requires WebGPU, falling back to 'pcf'`);
+            this.applyMode('pcf');
+            return;
+        }
         this._impl = null;
         if (mode === 'hard') {
             this._impl = new SSM();
@@ -914,6 +1022,8 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             esm.logSpace = this._esmLogSpace;
         } else if (mode === 'pcf' || mode === 'pcf-opt' || mode === 'pcf-pd') {
             this._impl = new PCFOPT(this._pcfKernelSize);
+        } else if (mode === 'dom') {
+            this._impl = new DOM(this._domLayerDistance, this._domDensity, this._domFilterSize);
         } else if (mode === 'pcss') {
             this._impl = new PCSS(this._pcssLightRadius, this._pcssBlockerSampleCount, this._pcssFilterSampleCount, this._pcssMaxFilterRadius, this._pcssTemporalJitter);
         }
@@ -921,6 +1031,9 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
     /** @internal */ asVSM() {
         return this._impl?.getType() === 'vsm' ? this._impl : null;
     }
+    /** @internal */ asDOM() {
+        return this._impl?.getType() === 'dom' ? this._impl : null;
+    }
     /** @internal */ asESM() {
         return this._impl?.getType() === 'esm' ? this._impl : null;
     }