@babylonjs/lite 0.1.1

package/pbr-transmission-ext-BxW4CEGu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbr-transmission-ext-BxW4CEGu.js","sources":["../src/resource/trilinear-anisotropic-sampler.ts","../src/frame-graph/transmission.ts","../src/material/pbr/fragments/refraction-rtt-fragment.ts","../src/material/pbr/pbr-transmission-ext.ts"],"sourcesContent":["import type { EngineContext } from \"../engine/engine.js\";\nimport { getOrCreateSampler } from \"./gpu-pool.js\";\n\nconst _trilinearAnisotropicDesc: GPUSamplerDescriptor = {\n    magFilter: \"linear\",\n    minFilter: \"linear\",\n    mipmapFilter: \"linear\",\n    addressModeU: \"repeat\",\n    addressModeV: \"repeat\",\n    addressModeW: \"repeat\",\n    maxAnisotropy: 4,\n};\n\nexport function getTrilinearAnisotropicSampler(engine: EngineContext): GPUSampler {\n    return getOrCreateSampler(engine, _trilinearAnisotropicDesc);\n}\n","import type { EngineContext } from \"../engine/engine.js\";\nimport { _vis } from \"../engine/engine.js\";\nimport { getBilinearSampler } from \"../resource/samplers.js\";\nimport { getTrilinearAnisotropicSampler } from \"../resource/trilinear-anisotropic-sampler.js\";\nimport type { Texture2D } from \"../texture/texture-2d.js\";\nimport { recordMipmaps } from \"../texture/generate-mipmaps.js\";\nimport { biasedMipLevelCount } from \"../texture/mip-count.js\";\nimport type { DrawBinding } from \"../render/renderable.js\";\nimport type { RenderTask } from \"./render-task.js\";\nimport type { SceneContext } from \"../scene/scene-core.js\";\nimport { createImageProcessingTask } from \"./image-processing-task.js\";\n\nexport interface RenderTaskTransmissionState {\n    readonly texture: Texture2D;\n    /** @internal */\n    readonly _baseView: GPUTextureView;\n    /** @internal */\n    _sourceWidth: number;\n    /** @internal */\n    _sourceHeight: number;\n    /** @internal */\n    _sourceTexture: GPUTexture | null;\n    /** @internal */\n    _blit: TransmissionBlitState | null;\n    /** @internal */\n    readonly _copyCount: number;\n    /** @internal */\n    readonly _generateMipmaps: boolean;\n    /** @internal */\n    _copies: number;\n}\n\ninterface TransmissionBlitState {\n    readonly _pipeline: GPURenderPipeline;\n    readonly _bindGroup: GPUBindGroup;\n}\n\nconst BLIT_SHADER = `@group(0)@binding(0)var t:texture_2d<f32>;@group(0)@binding(1)var s:sampler;struct V{@builtin(position)p:vec4f,@location(0)u:vec2f};@vertex fn vs(@builtin(vertex_index)i:u32)->V{var p=array<vec2f,3>(vec2f(-1,-1),vec2f(3,-1),vec2f(-1,3));var u=array<vec2f,3>(vec2f(0,1),vec2f(2,1),vec2f(0,-1));return V(vec4f(p[i],0,1),u[i]);}@fragment fn fs(v:V)->@location(0)vec4f{return textureSample(t,s,v.u);}`;\nconst BLIT_MSAA_SHADER = `@group(0)@binding(0)var t:texture_multisampled_2d<f32>;struct V{@builtin(position)p:vec4f,@location(0)u:vec2f};@vertex fn vs(@builtin(vertex_index)i:u32)->V{var p=array<vec2f,3>(vec2f(-1,-1),vec2f(3,-1),vec2f(-1,3));var u=array<vec2f,3>(vec2f(0,1),vec2f(2,1),vec2f(0,-1));return V(vec4f(p[i],0,1),u[i]);}fn l(p:vec2i)->vec4f{let n=textureNumSamples(t);var c=vec4f(0);for(var i=0u;i<n;i++){c+=textureLoad(t,p,i);}return c/f32(n);}@fragment fn fs(v:V)->@location(0)vec4f{let d=vec2i(textureDimensions(t));let q=clamp(v.u*vec2f(d)-.5,vec2f(0),vec2f(d-vec2i(1)));let p=vec2i(floor(q));let f=fract(q);let p1=min(p+vec2i(1),d-vec2i(1));return mix(mix(l(p),l(vec2i(p1.x,p.y)),f.x),mix(l(vec2i(p.x,p1.y)),l(p1),f.x),f.y);}`;\nconst REFRACTION_LOD_BIAS = 4;\nlet blitPipelines: Map<string, GPURenderPipeline> | null = null;\nlet blitShader: GPUShaderModule | null = null;\nlet blitMsaaShader: GPUShaderModule | null = null;\nlet blitBgl: GPUBindGroupLayout | null = null;\nlet blitMsaaBgl: GPUBindGroupLayout | null = null;\nlet blitDevice: GPUDevice | null = null;\n\nexport function enableSceneTransmission(scene: SceneContext, engine: EngineContext): void {\n    markPbrMaterialsLinear(scene);\n    let lastRenderTask: RenderTask | null = null;\n    for (const task of scene._frameGraph._tasks) {\n        if (\"_renderables\" in task) {\n            const renderTask = task as RenderTask;\n            enableRenderTaskTransmission(renderTask, engine);\n            lastRenderTask = renderTask;\n        }\n    }\n    if (lastRenderTask && !scene._frameGraph._tasks.some((task) => task.name === \"transmission-image-processing\")) {\n        scene._frameGraph._tasks.push(createImageProcessingTask({ name: \"transmission-image-processing\", source: lastRenderTask._config.rt }, engine, scene));\n    }\n}\n\nexport function enableRenderTaskTransmission(task: RenderTask, engine: EngineContext): void {\n    if (task._executeWithTransmission) {\n        return;\n    }\n    retargetRenderTaskToLinearOffscreen(task, engine);\n    let state: RenderTaskTransmissionState | null = null;\n    const record = task.record.bind(task);\n    const execute = task.execute?.bind(task);\n    const dispose = task.dispose?.bind(task);\n    task.record = () => {\n        disposeRenderTaskTransmission(state);\n        state = createRenderTaskTransmission(task, engine);\n        (task._targetSignature as { _transmissionTexture?: Texture2D })._transmissionTexture = state.texture;\n        record();\n        configureTransmissionSource(state, task, engine);\n    };\n    if (execute) {\n        task.execute = () => executeRenderTaskLinear(task.scene, execute);\n    }\n    task.dispose = () => {\n        disposeRenderTaskTransmission(state);\n        state = null;\n        dispose?.();\n    };\n    task._executeWithTransmission = (sampleCount) => executePassWithTransmission(task, engine, state!, sampleCount);\n}\n\nfunction retargetRenderTaskToLinearOffscreen(task: RenderTask, engine: EngineContext): void {\n    const desc = task._config.rt._descriptor;\n    if (desc.resolveToSwapchain) {\n        desc.resolveToSwapchain = false;\n        desc.colorFormat = \"rgba16float\";\n        desc.flipY = false;\n        task._opaqueBundles.length = 0;\n        task._lastVersion = -1;\n    } else if (!desc.colorFormat) {\n        desc.colorFormat = \"rgba16float\";\n    }\n    desc.sampleCount = engine.msaaSamples;\n    const sig = task._targetSignature as {\n        _colorFormat?: GPUTextureFormat;\n        _depthStencilFormat?: GPUTextureFormat;\n        _depthCompare?: GPUCompareFunction;\n        _sampleCount: number;\n        _flipY?: boolean;\n    };\n    sig._colorFormat = desc.colorFormat;\n    sig._depthStencilFormat = desc.depthStencilFormat;\n    sig._depthCompare = desc._depthCompare;\n    sig._sampleCount = desc.sampleCount;\n    sig._flipY = desc.flipY ?? true;\n}\n\nfunction executeRenderTaskLinear(scene: SceneContext, execute: () => number): number {\n    const imageProcessing = scene.imageProcessing as { exposure: number; contrast: number; toneMappingEnabled: boolean | number };\n    const toneMappingEnabled = imageProcessing.toneMappingEnabled;\n    const clearColor = scene.clearColor;\n    const linearClearColor = inverseImageProcessedColor(clearColor, imageProcessing.exposure, imageProcessing.contrast, toneMappingEnabled === true);\n    imageProcessing.toneMappingEnabled = -1;\n    scene.clearColor = linearClearColor;\n    try {\n        return execute();\n    } finally {\n        scene.clearColor = clearColor;\n        imageProcessing.toneMappingEnabled = toneMappingEnabled;\n    }\n}\n\nfunction inverseImageProcessedColor(color: GPUColorDict, exposure: number, contrast: number, toneMapping: boolean): GPUColorDict {\n    return {\n        r: inverseImageProcessedChannel(color.r, exposure, contrast, toneMapping),\n        g: inverseImageProcessedChannel(color.g, exposure, contrast, toneMapping),\n        b: inverseImageProcessedChannel(color.b, exposure, contrast, toneMapping),\n        a: color.a,\n    };\n}\n\nfunction inverseImageProcessedChannel(value: number, exposure: number, contrast: number, toneMapping: boolean): number {\n    let c = clamp01(value);\n    if (contrast < 1) {\n        c = contrast > 0 ? clamp01((c - 0.5 * (1 - contrast)) / contrast) : 0.5;\n    } else if (contrast > 1) {\n        const mixAmount = contrast - 1;\n        let lo = 0;\n        let hi = 1;\n        for (let i = 0; i < 16; i++) {\n            const mid = (lo + hi) * 0.5;\n            const high = mid * mid * (3 - 2 * mid);\n            const out = mid + (high - mid) * mixAmount;\n            if (out < c) {\n                lo = mid;\n            } else {\n                hi = mid;\n            }\n        }\n        c = (lo + hi) * 0.5;\n    }\n    c = c ** 2.2;\n    if (toneMapping) {\n        c = -Math.log2(Math.max(1 - c, 1e-6)) / 1.5905790328979492;\n    }\n    return exposure > 0 ? c / exposure : c;\n}\n\nfunction clamp01(v: number): number {\n    return Math.min(Math.max(v, 0), 1);\n}\n\nfunction markPbrMaterialsLinear(scene: SceneContext): void {\n    for (const mesh of scene.meshes) {\n        const mat = mesh.material as { _linearImageProcessing?: boolean; _renderFeatures?: unknown } | undefined;\n        if (mat) {\n            mat._linearImageProcessing = true;\n            mat._renderFeatures = undefined;\n        }\n    }\n}\n\nfunction createRenderTaskTransmission(task: RenderTask, engine: EngineContext): RenderTaskTransmissionState {\n    const rt = task._config.rt;\n    const width = 1024;\n    const height = 1024;\n    const format: GPUTextureFormat = \"rgba16float\";\n    const generateMipmaps = shouldGenerateMipmaps(task._config.transmission);\n    const texture = engine._device.createTexture({\n        label: task.name,\n        size: { width, height },\n        format,\n        mipLevelCount: generateMipmaps ? biasedMipLevelCount(width, height, REFRACTION_LOD_BIAS) : 1,\n        usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,\n    });\n    const tex: Texture2D = {\n        texture,\n        view: texture.createView(),\n        sampler: getTrilinearAnisotropicSampler(engine),\n        width,\n        height,\n        invertY: false,\n    };\n    return {\n        texture: tex,\n        _baseView: texture.createView({ baseMipLevel: 0, mipLevelCount: 1 }),\n        _sourceWidth: rt._width,\n        _sourceHeight: rt._height,\n        _sourceTexture: null,\n        _blit: null,\n        _copyCount: normalizeCopyCount(task._config.transmission),\n        _generateMipmaps: generateMipmaps,\n        _copies: 0,\n    };\n}\n\nfunction configureTransmissionSource(state: RenderTaskTransmissionState, task: RenderTask, engine: EngineContext): void {\n    const rt = task._config.rt;\n    state._sourceWidth = rt._width;\n    state._sourceHeight = rt._height;\n    state._sourceTexture = rt._colorTexture;\n    const sampleCount = task._targetSignature._sampleCount;\n    if (!state._sourceTexture) {\n        return;\n    }\n    state._blit = shouldBlitTransmission(state, sampleCount) ? createTransmissionBlit(state, engine, state._sourceTexture, sampleCount > 1) : null;\n}\n\nfunction disposeRenderTaskTransmission(state: RenderTaskTransmissionState | null | undefined): void {\n    state?.texture.texture.destroy();\n}\n\nexport function executePassWithTransmission(task: RenderTask, engine: EngineContext, state: RenderTaskTransmissionState, sampleCount: number): number {\n    state._copies = 0;\n    const transparent = task._transparentBindings;\n    let pass = beginTaskPass(task, null, sampleCount, false);\n    let draws = drawBaseTask(task, pass);\n    let lastPipeline: GPURenderPipeline | null = null;\n    for (let i = 0; i < transparent.length; i++) {\n        const binding = transparent[i]!;\n        const transmissive = binding.renderable._transmissive === true;\n        if (transmissive && canUpdateTransmission(state)) {\n            pass.end();\n            updateTransmissionTexture(state, engine);\n            pass = beginTaskPass(task, null, sampleCount, true);\n            setPassState(task, pass);\n            lastPipeline = null;\n        }\n        const mesh = binding.renderable.mesh;\n        if (mesh && mesh.visible === false) {\n            continue;\n        }\n        if (binding.pipeline !== lastPipeline) {\n            pass.setPipeline(binding.pipeline);\n            lastPipeline = binding.pipeline;\n        }\n        draws += binding.draw(pass, engine);\n    }\n    pass.end();\n    return draws;\n}\n\nfunction updateTransmissionTexture(state: RenderTaskTransmissionState, engine: EngineContext): void {\n    if (!state._sourceTexture) {\n        throw new Error(\"No transmission source\");\n    }\n    if (state._blit) {\n        blitToTransmission(state, engine);\n    } else {\n        engine._currentEncoder.copyTextureToTexture(\n            { texture: state._sourceTexture },\n            { texture: state.texture.texture },\n            { width: state.texture.width, height: state.texture.height }\n        );\n    }\n    if (state._generateMipmaps) {\n        recordMipmaps(engine, state.texture.texture, engine._currentEncoder);\n    }\n    state._copies++;\n}\n\nfunction getBlitPipeline(engine: EngineContext, format: GPUTextureFormat, multisampled: boolean): GPURenderPipeline {\n    const device = engine._device;\n    if (device !== blitDevice) {\n        blitPipelines?.clear();\n        blitPipelines = null;\n        blitShader = null;\n        blitMsaaShader = null;\n        blitBgl = null;\n        blitMsaaBgl = null;\n        blitDevice = device;\n    }\n    if (multisampled) {\n        blitMsaaShader ??= device.createShaderModule({ code: BLIT_MSAA_SHADER });\n        blitMsaaBgl ??= device.createBindGroupLayout({\n            entries: [{ binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: \"unfilterable-float\", multisampled: true } }],\n        });\n    } else {\n        blitShader ??= device.createShaderModule({ code: BLIT_SHADER });\n        blitBgl ??= device.createBindGroupLayout({\n            entries: [\n                { binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: \"float\" } },\n                { binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: {} },\n            ],\n        });\n    }\n    blitPipelines ??= new Map();\n    const key = `${format}:${multisampled ? \"msaa\" : \"\"}`;\n    let pipeline = blitPipelines.get(key);\n    if (!pipeline) {\n        const bgl = multisampled ? blitMsaaBgl! : blitBgl!;\n        pipeline = device.createRenderPipeline({\n            label: \"transmission-copy\",\n            layout: device.createPipelineLayout({ bindGroupLayouts: [bgl] }),\n            vertex: { module: multisampled ? blitMsaaShader! : blitShader!, entryPoint: \"vs\" },\n            fragment: { module: multisampled ? blitMsaaShader! : blitShader!, entryPoint: \"fs\", targets: [{ format }] },\n            primitive: { topology: \"triangle-list\" },\n        });\n        blitPipelines.set(key, pipeline);\n    }\n    return pipeline;\n}\n\nfunction shouldBlitTransmission(state: RenderTaskTransmissionState, sampleCount: number): boolean {\n    return sampleCount > 1 || state._sourceWidth !== state.texture.width || state._sourceHeight !== state.texture.height;\n}\n\nfunction createTransmissionBlit(state: RenderTaskTransmissionState, engine: EngineContext, source: GPUTexture, multisampled: boolean): TransmissionBlitState {\n    const device = engine._device;\n    const pipeline = getBlitPipeline(engine, state.texture.texture.format, multisampled);\n    const bindGroup = device.createBindGroup({\n        layout: multisampled ? blitMsaaBgl! : blitBgl!,\n        entries: multisampled\n            ? [{ binding: 0, resource: source.createView() }]\n            : [\n                  { binding: 0, resource: source.createView() },\n                  { binding: 1, resource: getBilinearSampler(engine) },\n              ],\n    });\n    return { _pipeline: pipeline, _bindGroup: bindGroup };\n}\n\nfunction blitToTransmission(state: RenderTaskTransmissionState, engine: EngineContext): void {\n    const blit = state._blit!;\n    const pass = engine._currentEncoder.beginRenderPass({\n        colorAttachments: [{ view: state._baseView, loadOp: \"clear\", storeOp: \"store\", clearValue: { r: 0, g: 0, b: 0, a: 0 } }],\n    });\n    pass.setPipeline(blit._pipeline);\n    pass.setBindGroup(0, blit._bindGroup);\n    pass.draw(3);\n    pass.end();\n}\n\nfunction canUpdateTransmission(state: RenderTaskTransmissionState): boolean {\n    return state._copyCount === 0 || state._copies < state._copyCount;\n}\n\nfunction beginTaskPass(task: RenderTask, resolveTarget: GPUTextureView | null, sampleCount: number, load: boolean): GPURenderPassEncoder {\n    const att = task._colorAttachment;\n    const depthLoadOp = load || !task._config.clr ? \"load\" : \"clear\";\n    if (load) {\n        att.loadOp = \"load\";\n    }\n    const depthAttachment = task._renderPassDescriptor.depthStencilAttachment;\n    if (depthAttachment) {\n        depthAttachment.depthLoadOp = depthLoadOp;\n        if (depthAttachment.stencilLoadOp) {\n            depthAttachment.stencilLoadOp = depthLoadOp;\n        }\n    }\n    if (sampleCount > 1) {\n        att.resolveTarget = resolveTarget ?? undefined;\n    } else {\n        att.resolveTarget = undefined;\n    }\n    return task.engine._currentEncoder.beginRenderPass(task._renderPassDescriptor);\n}\n\nfunction setPassState(task: RenderTask, pass: GPURenderPassEncoder): void {\n    const cfg = task._config;\n    const rt = cfg.rt;\n    const scene = task.scene;\n    const camera = cfg.cam ?? scene.camera;\n    const v = camera?.viewport;\n    if (v) {\n        const rw = rt._width;\n        const rh = rt._height;\n        const x = Math.floor(v.x * rw);\n        const y = Math.floor((1 - v.y - v.height) * rh);\n        const w = Math.ceil((v.x + v.width) * rw) - x;\n        const h = Math.ceil((1 - v.y) * rh) - y;\n        pass.setViewport(x, y, w, h, 0, 1);\n        pass.setScissorRect(x, y, w, h);\n    }\n    pass.setBindGroup(0, task._sceneBG);\n}\n\nfunction drawBaseTask(task: RenderTask, pass: GPURenderPassEncoder): number {\n    const eng = task.engine;\n    const rt = task._config.rt;\n    const scene = task.scene;\n    const opaqueBindings = task._opaqueBindings;\n    const opaqueBundles = task._opaqueBundles;\n\n    setPassState(task, pass);\n\n    if (task._lastVersion !== scene._renderableVersion || task._lastVis !== _vis || opaqueBundles.length === 0) {\n        const desc = rt._descriptor;\n        const be = eng._device.createRenderBundleEncoder({\n            colorFormats: desc.colorFormat ? [desc.colorFormat] : [],\n            depthStencilFormat: desc.depthStencilFormat,\n            sampleCount: desc.sampleCount ?? 1,\n        });\n        be.setBindGroup(0, task._sceneBG);\n        drawList(be, opaqueBindings, eng);\n        opaqueBundles[0] = be.finish();\n        task._lastVersion = scene._renderableVersion;\n        task._lastVis = _vis;\n    }\n    let draws = opaqueBindings.length;\n    pass.executeBundles(opaqueBundles);\n    pass.setBindGroup(0, task._sceneBG);\n    draws += drawList(pass, task._directBindings, eng);\n    return draws;\n}\n\nfunction drawList(enc: GPURenderPassEncoder | GPURenderBundleEncoder, list: readonly DrawBinding[], engine: EngineContext): number {\n    let lp: GPURenderPipeline | null = null;\n    let draws = 0;\n    for (const b of list) {\n        const mesh = b.renderable.mesh;\n        if (mesh && mesh.visible === false) {\n            continue;\n        }\n        if (b.pipeline !== lp) {\n            enc.setPipeline(b.pipeline);\n            lp = b.pipeline;\n        }\n        draws += b.draw(enc, engine);\n    }\n    return draws;\n}\n\nfunction normalizeCopyCount(cfg: RenderTask[\"_config\"][\"transmission\"]): number {\n    const count = cfg?.copyCount ?? 1;\n    return count === Infinity ? 0 : Math.max(0, count | 0);\n}\n\nfunction shouldGenerateMipmaps(cfg: RenderTask[\"_config\"][\"transmission\"]): boolean {\n    return cfg?.generateMipmaps !== false;\n}\n","import type { ShaderFragment, UboField } from \"../../../shader/fragment-types.js\";\nimport type { PbrMaterialProps, SubSurfaceProps } from \"../pbr-material.js\";\nimport type { PbrExt } from \"../pbr-flags.js\";\nimport { getTrilinearAnisotropicSampler } from \"../../../resource/trilinear-anisotropic-sampler.js\";\nimport {\n    PBR_HAS_THICKNESS_MAP,\n    PBR2_HAS_DISPERSION,\n    PBR2_HAS_REFRACTION,\n    PBR2_HAS_REFRACTION_MAP,\n    PBR2_HAS_THICKNESS_GLTF_CHANNEL,\n    PBR2_HAS_VOLUME,\n    PBR2_LINEAR_IMAGE_PROCESSING,\n} from \"../pbr-flag-bits.js\";\n\ntype TransmissionMat = PbrMaterialProps & { _linearImageProcessing?: boolean };\nconst LINEAR_IMAGE_PROCESSING_SLOTS = { NI: `if(scene.vImageInfos.w>=0.0){`, BC: `}` };\n\nfunction makeRefractionMod(\n    hasVolume: boolean,\n    hasMap: boolean,\n    hasThicknessMap: boolean,\n    useGltfThicknessChannel: boolean,\n    hasDispersion: boolean,\n    dispersionSampleWgsl: string | undefined\n): string {\n    const thicknessScaleLine = hasVolume || hasThicknessMap ? `let ts=max(length(mesh.world[0].xyz),max(length(mesh.world[1].xyz),length(mesh.world[2].xyz)));` : ``;\n    const thicknessLine = hasThicknessMap\n        ? `let ths=textureSample(thicknessTexture_,thicknessSampler_,input.uv).${useGltfThicknessChannel ? \"g\" : \"r\"};\nlet th=(material.thicknessParams.x+ths*material.thicknessParams.y)*ts;`\n        : hasVolume\n          ? `let th=material.refractionParams.z*ts;`\n          : `let th=material.refractionParams.z;`;\n    const textureLine = hasMap ? `let ri=material.refractionParams.x*textureSample(refractionMapTexture,refractionMapSampler,input.uv).r;` : `let ri=material.refractionParams.x;`;\n    const absorptionLine = hasVolume ? `let ab=exp(material.volumeParams.rgb*th);` : ``;\n    const refractionLine = hasVolume\n        ? `let fr=er*surfaceAlbedo*(ri*ab)*(vec3<f32>(1.0)-colorSpecularEnvReflectance.rgb);`\n        : `let fr=er*surfaceAlbedo*ri*(vec3<f32>(1.0)-colorSpecularEnvReflectance.rgb);`;\n\n    // Refracted environment sample. Dispersion splits the refracted ray into\n    // per-RGB index-of-refraction offsets (chromatic aberration); that 3-ray WGSL\n    // is injected from a dynamically-imported module (see refraction-dispersion-wgsl.ts)\n    // so non-dispersion transmission scenes keep the lean single-ray path below.\n    const sampleLines =\n        hasDispersion && dispersionSampleWgsl\n            ? dispersionSampleWgsl\n            : `let rd=refract(-V,N,material.refractionParams.y);\nlet cp=scene.viewProjection*vec4<f32>(input.worldPos+rd*th,1.0);\nlet ruv=(cp.xy/cp.w)*vec2<f32>(0.5,-0.5)+vec2<f32>(0.5,0.5);\nlet er=textureSampleLevel(refractionTexture,refractionSampler_,ruv,lv).rgb*material.environmentIntensity;`;\n\n    return `{\n${thicknessScaleLine}\n${textureLine}\n${thicknessLine}\nlet ro=1.0-ri;\nlet ra=mix(alphaG,0.0,clamp(material.refractionParams.w*3.0-2.0,0.0,1.0));\nlet lv=clamp(log2(f32(textureDimensions(refractionTexture).x)*ra)-4.0,0.0,f32(textureNumLevels(refractionTexture)-1));\n${sampleLines}\n${absorptionLine}\n${refractionLine}\ncolor=finalIrradiance*ro*ro+finalRadianceScaled+finalSpecularScaled+directDiffuse*ro*ro+fr+emissive;\n}`;\n}\n\nfunction createRefractionRttFragment(\n    hasVolume: boolean,\n    hasMap: boolean,\n    hasThicknessMap: boolean,\n    useGltfThicknessChannel: boolean,\n    linearImageProcessing: boolean,\n    hasDispersion: boolean,\n    dispersionSampleWgsl: string | undefined\n): ShaderFragment {\n    const uboFields: UboField[] = [{ _name: \"refractionParams\", _type: \"vec4<f32>\" as const }];\n    if (hasVolume) {\n        uboFields.push({ _name: \"volumeParams\", _type: \"vec4<f32>\" as const });\n    }\n    if (hasThicknessMap) {\n        uboFields.push({ _name: \"thicknessParams\", _type: \"vec4<f32>\" as const });\n    }\n    const bindings = [\n        { _name: \"refractionTexture\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" } as const, _visibility: 2 },\n        { _name: \"refractionSampler_\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" } as const, _visibility: 2 },\n    ];\n    if (hasMap) {\n        bindings.push(\n            { _name: \"refractionMapTexture\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" } as const, _visibility: 2 },\n            { _name: \"refractionMapSampler\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" } as const, _visibility: 2 }\n        );\n    }\n    if (hasThicknessMap) {\n        bindings.push(\n            { _name: \"thicknessTexture_\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" } as const, _visibility: 2 },\n            { _name: \"thicknessSampler_\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" } as const, _visibility: 2 }\n        );\n    }\n    return {\n        _id: \"refraction\",\n        _dependencies: [\"ibl\"],\n        _uboFields: uboFields,\n        _bindings: bindings,\n        _fragmentSlots: linearImageProcessing\n            ? { AI: makeRefractionMod(hasVolume, hasMap, hasThicknessMap, useGltfThicknessChannel, hasDispersion, dispersionSampleWgsl), ...LINEAR_IMAGE_PROCESSING_SLOTS }\n            : { AI: makeRefractionMod(hasVolume, hasMap, hasThicknessMap, useGltfThicknessChannel, hasDispersion, dispersionSampleWgsl) },\n    };\n}\n\nfunction writeRefractionUBO(data: Float32Array, mat: PbrMaterialProps, offsets: ReadonlyMap<string, number>): void {\n    const ss = mat.subsurface as SubSurfaceProps | undefined;\n    const refr = ss?.refraction;\n    if (!refr) {\n        return;\n    }\n    const off = offsets.get(\"refractionParams\");\n    if (off === undefined) {\n        return;\n    }\n    const o = off / 4;\n    data[o] = refr.intensity ?? 0;\n    const ior = refr.indexOfRefraction ?? 1.5;\n    const thick = ss!.thickness;\n    data[o + 1] = 1.0 / (refr.useThicknessAsDepth && thick?.max ? ior : 1.0);\n    data[o + 2] = refr.useThicknessAsDepth ? (thick?.max ?? 0.0) : 1.0;\n    data[o + 3] = 1.0 / ior;\n\n    const vOff = offsets.get(\"volumeParams\");\n    if (vOff !== undefined) {\n        const vo = vOff / 4;\n        const tint = ss!.tint?.color ?? [1, 1, 1];\n        const dist = Math.max(ss!.tint?.atDistance ?? 1, 0.0001);\n        data[vo] = Math.log(Math.max(tint[0]!, 1e-6)) / dist;\n        data[vo + 1] = Math.log(Math.max(tint[1]!, 1e-6)) / dist;\n        data[vo + 2] = Math.log(Math.max(tint[2]!, 1e-6)) / dist;\n        // w carries the chromatic dispersion strength (0 when no KHR_materials_dispersion).\n        data[vo + 3] = refr.dispersion ?? 0;\n    }\n\n    const tOff = offsets.get(\"thicknessParams\");\n    if (tOff !== undefined) {\n        const to = tOff / 4;\n        const min = thick?.min ?? 0;\n        const max = thick?.max ?? 1;\n        data[to] = min;\n        data[to + 1] = max - min;\n    }\n}\n\n/** Build the PBR refraction/transmission extension. When the scene contains a\n *  dispersive material, `dispersionSampleWgsl` carries the per-RGB 3-ray sample\n *  WGSL (dynamically imported, scene-isolated); otherwise it is undefined and the\n *  lean single-ray refraction path is emitted. */\nexport function makeRefractionRttExt(dispersionSampleWgsl?: string): PbrExt {\n    return {\n        id: \"refraction\",\n        phase: \"fragment\",\n        detect(mat) {\n            const m = mat as TransmissionMat;\n            const ss = m.subsurface as SubSurfaceProps | undefined;\n            const refr = ss?.refraction;\n            const linearImageProcessing = m._linearImageProcessing ? PBR2_LINEAR_IMAGE_PROCESSING : 0;\n            const intensity = m.transmissive ? (refr?.intensity ?? 0) : 0;\n            if (intensity <= 0) {\n                return { f: 0, f2: linearImageProcessing };\n            }\n            let f = 0;\n            let f2 = linearImageProcessing | PBR2_HAS_REFRACTION;\n            if (refr?.texture) {\n                f2 |= PBR2_HAS_REFRACTION_MAP;\n            }\n            if (ss?.thickness?.texture) {\n                f |= PBR_HAS_THICKNESS_MAP;\n            }\n            if (ss?.thickness?.useGlTFChannel) {\n                f2 |= PBR2_HAS_THICKNESS_GLTF_CHANNEL;\n            }\n            if (ss?.tint?.atDistance !== undefined) {\n                f2 |= PBR2_HAS_VOLUME;\n                // Dispersion requires the volume path (per-channel etas + volumeParams.w storage).\n                if (refr?.dispersion) {\n                    f2 |= PBR2_HAS_DISPERSION;\n                }\n            }\n            return { f, f2 };\n        },\n        frag(ctx) {\n            const linearImageProcessing = (ctx._features2 & PBR2_LINEAR_IMAGE_PROCESSING) !== 0;\n            if (!(ctx._features2 & PBR2_HAS_REFRACTION)) {\n                return linearImageProcessing ? { _id: \"linear\", _fragmentSlots: LINEAR_IMAGE_PROCESSING_SLOTS } : null;\n            }\n            return createRefractionRttFragment(\n                (ctx._features2 & PBR2_HAS_VOLUME) !== 0,\n                (ctx._features2 & PBR2_HAS_REFRACTION_MAP) !== 0,\n                (ctx._features & PBR_HAS_THICKNESS_MAP) !== 0,\n                (ctx._features2 & PBR2_HAS_THICKNESS_GLTF_CHANNEL) !== 0,\n                linearImageProcessing,\n                (ctx._features2 & PBR2_HAS_DISPERSION) !== 0,\n                dispersionSampleWgsl\n            );\n        },\n        writeUbo(data, mat, offsets) {\n            writeRefractionUBO(data, mat as PbrMaterialProps, offsets);\n        },\n        bind(ctx, entries, b) {\n            if (!(ctx._features2 & PBR2_HAS_REFRACTION)) {\n                return b;\n            }\n            const texture = ctx._refractionTexture;\n            if (!texture) {\n                throw new Error(\"PBR transmission requires a frame-graph refraction texture.\");\n            }\n            entries.push({ binding: b++, resource: texture.view });\n            entries.push({ binding: b++, resource: texture.sampler });\n            if ((ctx._features2 & PBR2_HAS_REFRACTION_MAP) !== 0) {\n                const map = ((ctx._material as PbrMaterialProps).subsurface?.refraction as SubSurfaceProps[\"refraction\"] | undefined)?.texture!;\n                entries.push({ binding: b++, resource: map.view });\n                entries.push({ binding: b++, resource: getTrilinearAnisotropicSampler(ctx._engine) });\n            }\n            if ((ctx._features & PBR_HAS_THICKNESS_MAP) !== 0) {\n                const thickness = (ctx._material as PbrMaterialProps).subsurface?.thickness?.texture!;\n                entries.push({ binding: b++, resource: thickness.view });\n                entries.push({ binding: b++, resource: thickness.sampler });\n            }\n            return b;\n        },\n        textures(mat, out) {\n            const tex = (mat as PbrMaterialProps).subsurface?.refraction?.texture;\n            if (tex) {\n                out.push(tex);\n            }\n            const thickness = (mat as PbrMaterialProps).subsurface?.thickness?.texture;\n            if (thickness) {\n                out.push(thickness);\n            }\n        },\n    };\n}\n","import type { SceneContext } from \"../../scene/scene.js\";\nimport type { EngineContext } from \"../../engine/engine.js\";\nimport type { PbrExt } from \"./pbr-flags.js\";\nimport { enableSceneTransmission } from \"../../frame-graph/transmission.js\";\nimport { makeRefractionRttExt } from \"./fragments/refraction-rtt-fragment.js\";\n\nexport function registerPbrTransmission(scene: SceneContext, engine: EngineContext, register: (ext: PbrExt) => void, dispersionSampleWgsl?: string): void {\n    enableSceneTransmission(scene, engine);\n    register(makeRefractionRttExt(dispersionSampleWgsl));\n}\n"],"names":[],"mappings":"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"}

package/perturb-normal-0Q8EM9ig.js

@@ -0,0 +1,39 @@
+const HELPER_KEY = "nme_perturbNormal";
+const HELPER_WGSL = `
+fn nme_perturbNormal(worldPos: vec3<f32>, worldNormal: vec3<f32>, uv: vec2<f32>, sampled: vec3<f32>, strength: f32) -> vec3<f32> {
+    // Construct ad-hoc TBN from screen-space derivatives. WebGPU's UV.y goes top-down
+    // (BJS GLSL UV is bottom-up), so dpdy and duv2 both end up with opposite sign vs BJS.
+    // Negating BOTH dp2 AND duv2 cancels the framebuffer Y-flip without flipping the
+    // tangent orientation. This produces the same TBN as BJS does at the same fragment.
+    let dp1 = dpdx(worldPos);
+    let dp2 = -dpdy(worldPos);
+    let duv1 = dpdx(uv);
+    let duv2 = -dpdy(uv);
+    let dp2perp = cross(dp2, worldNormal);
+    let dp1perp = cross(worldNormal, dp1);
+    let T = dp2perp * duv1.x + dp1perp * duv2.x;
+    let B = dp2perp * duv1.y + dp1perp * duv2.y;
+    let invmax = inverseSqrt(max(dot(T, T), dot(B, B)));
+    let n = sampled * 2.0 - vec3<f32>(1.0);
+    let scaled = vec3<f32>(n.xy * strength, n.z);
+    return normalize(T * scaled.x * invmax + B * scaled.y * invmax + worldNormal * scaled.z);
+}
+`;
+const emitter = {
+  className: "PerturbNormalBlock",
+  stage: "fragment",
+  emit(block, _outputName, stage, state, ctx) {
+    state.fragment.helpers.set(HELPER_KEY, HELPER_WGSL);
+    const wp = ctx.cast(ctx.resolve(block, "worldPosition", stage, state), "vec3f").expr;
+    const wn = ctx.cast(ctx.resolve(block, "worldNormal", stage, state), "vec3f").expr;
+    const uv = ctx.cast(ctx.resolve(block, "uv", stage, state), "vec2f").expr;
+    const nm = ctx.cast(ctx.resolve(block, "normalMapColor", stage, state), "vec3f").expr;
+    const strInput = block.inputs.get("strength");
+    const strength = (strInput == null ? void 0 : strInput.source) ? ctx.cast(ctx.resolve(block, "strength", stage, state), "f32").expr : "1.0";
+    return { expr: `nme_perturbNormal(${wp}, ${wn}, ${uv}, ${nm}, ${strength})`, type: "vec3f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=perturb-normal-0Q8EM9ig.js.map

package/perturb-normal-0Q8EM9ig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"perturb-normal-0Q8EM9ig.js","sources":["../src/material/node/blocks/perturb-normal.ts"],"sourcesContent":["/** PerturbNormalBlock — tangent-space normal-map perturbation.\n *\n *  Inputs: worldPosition, worldNormal, worldTangent (optional), uv, normalMapColor, strength.\n *  Output: output (vec3 world-space normal).\n *\n *  If worldTangent is supplied we use the true TBN; otherwise we derive an\n *  ad-hoc TBN from screen-space derivatives (matches BJS `useParallax`-off\n *  fallback).\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nconst HELPER_KEY = \"nme_perturbNormal\";\nconst HELPER_WGSL = `\nfn nme_perturbNormal(worldPos: vec3<f32>, worldNormal: vec3<f32>, uv: vec2<f32>, sampled: vec3<f32>, strength: f32) -> vec3<f32> {\n    // Construct ad-hoc TBN from screen-space derivatives. WebGPU's UV.y goes top-down\n    // (BJS GLSL UV is bottom-up), so dpdy and duv2 both end up with opposite sign vs BJS.\n    // Negating BOTH dp2 AND duv2 cancels the framebuffer Y-flip without flipping the\n    // tangent orientation. This produces the same TBN as BJS does at the same fragment.\n    let dp1 = dpdx(worldPos);\n    let dp2 = -dpdy(worldPos);\n    let duv1 = dpdx(uv);\n    let duv2 = -dpdy(uv);\n    let dp2perp = cross(dp2, worldNormal);\n    let dp1perp = cross(worldNormal, dp1);\n    let T = dp2perp * duv1.x + dp1perp * duv2.x;\n    let B = dp2perp * duv1.y + dp1perp * duv2.y;\n    let invmax = inverseSqrt(max(dot(T, T), dot(B, B)));\n    let n = sampled * 2.0 - vec3<f32>(1.0);\n    let scaled = vec3<f32>(n.xy * strength, n.z);\n    return normalize(T * scaled.x * invmax + B * scaled.y * invmax + worldNormal * scaled.z);\n}\n`;\n\nexport const emitter: BlockEmitter = {\n    className: \"PerturbNormalBlock\",\n    stage: \"fragment\",\n    emit(block, _outputName, stage, state, ctx) {\n        state.fragment.helpers.set(HELPER_KEY, HELPER_WGSL);\n        const wp = ctx.cast(ctx.resolve(block, \"worldPosition\", stage, state), \"vec3f\").expr;\n        const wn = ctx.cast(ctx.resolve(block, \"worldNormal\", stage, state), \"vec3f\").expr;\n        const uv = ctx.cast(ctx.resolve(block, \"uv\", stage, state), \"vec2f\").expr;\n        const nm = ctx.cast(ctx.resolve(block, \"normalMapColor\", stage, state), \"vec3f\").expr;\n        const strInput = block.inputs.get(\"strength\");\n        const strength = strInput?.source ? ctx.cast(ctx.resolve(block, \"strength\", stage, state), \"f32\").expr : \"1.0\";\n        return { expr: `nme_perturbNormal(${wp}, ${wn}, ${uv}, ${nm}, ${strength})`, type: \"vec3f\" };\n    },\n};\n"],"names":[],"mappings":"AAYA,MAAM,aAAa;AACnB,MAAM,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBb,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,SAAS,QAAQ,IAAI,YAAY,WAAW;AAClD,UAAM,KAAK,IAAI,KAAK,IAAI,QAAQ,OAAO,iBAAiB,OAAO,KAAK,GAAG,OAAO,EAAE;AAChF,UAAM,KAAK,IAAI,KAAK,IAAI,QAAQ,OAAO,eAAe,OAAO,KAAK,GAAG,OAAO,EAAE;AAC9E,UAAM,KAAK,IAAI,KAAK,IAAI,QAAQ,OAAO,MAAM,OAAO,KAAK,GAAG,OAAO,EAAE;AACrE,UAAM,KAAK,IAAI,KAAK,IAAI,QAAQ,OAAO,kBAAkB,OAAO,KAAK,GAAG,OAAO,EAAE;AACjF,UAAM,WAAW,MAAM,OAAO,IAAI,UAAU;AAC5C,UAAM,YAAW,qCAAU,UAAS,IAAI,KAAK,IAAI,QAAQ,OAAO,YAAY,OAAO,KAAK,GAAG,KAAK,EAAE,OAAO;AACzG,WAAO,EAAE,MAAM,qBAAqB,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,QAAQ,KAAK,MAAM,QAAA;AAAA,EACvF;AACJ;"}

package/posterize-block-DfdKsbEf.js

@@ -0,0 +1,28 @@
+function one(type) {
+  if (type === "f32") {
+    return "1.0";
+  }
+  if (type === "vec2f") {
+    return "vec2<f32>(1.0)";
+  }
+  if (type === "vec3f") {
+    return "vec3<f32>(1.0)";
+  }
+  if (type === "vec4f") {
+    return "vec4<f32>(1.0)";
+  }
+  throw new Error(`NodeMaterial: PosterizeBlock does not support ${type}`);
+}
+const emitter = {
+  className: "PosterizeBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const value = ctx.resolve(block, "value", stage, state);
+    const steps = ctx.cast(ctx.resolve(block, "steps", stage, state), value.type).expr;
+    const interval = `(${one(value.type)} / ${steps})`;
+    return { expr: `(floor(${value.expr} / ${interval}) * ${interval})`, type: value.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=posterize-block-DfdKsbEf.js.map

package/posterize-block-DfdKsbEf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"posterize-block-DfdKsbEf.js","sources":["../src/material/node/blocks/posterize-block.ts"],"sourcesContent":["import type { BlockEmitter, NodeValueType } from \"../node-types.js\";\n\nfunction one(type: NodeValueType): string {\n    if (type === \"f32\") {\n        return \"1.0\";\n    }\n    if (type === \"vec2f\") {\n        return \"vec2<f32>(1.0)\";\n    }\n    if (type === \"vec3f\") {\n        return \"vec3<f32>(1.0)\";\n    }\n    if (type === \"vec4f\") {\n        return \"vec4<f32>(1.0)\";\n    }\n    throw new Error(`NodeMaterial: PosterizeBlock does not support ${type}`);\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"PosterizeBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const value = ctx.resolve(block, \"value\", stage, state);\n        const steps = ctx.cast(ctx.resolve(block, \"steps\", stage, state), value.type).expr;\n        const interval = `(${one(value.type)} / ${steps})`;\n        return { expr: `(floor(${value.expr} / ${interval}) * ${interval})`, type: value.type };\n    },\n};\n"],"names":[],"mappings":"AAEA,SAAS,IAAI,MAA6B;AACtC,MAAI,SAAS,OAAO;AAChB,WAAO;AAAA,EACX;AACA,MAAI,SAAS,SAAS;AAClB,WAAO;AAAA,EACX;AACA,MAAI,SAAS,SAAS;AAClB,WAAO;AAAA,EACX;AACA,MAAI,SAAS,SAAS;AAClB,WAAO;AAAA,EACX;AACA,QAAM,IAAI,MAAM,iDAAiD,IAAI,EAAE;AAC3E;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,QAAQ,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AACtD,UAAM,QAAQ,IAAI,KAAK,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK,GAAG,MAAM,IAAI,EAAE;AAC9E,UAAM,WAAW,IAAI,IAAI,MAAM,IAAI,CAAC,MAAM,KAAK;AAC/C,WAAO,EAAE,MAAM,UAAU,MAAM,IAAI,MAAM,QAAQ,OAAO,QAAQ,KAAK,MAAM,MAAM,KAAA;AAAA,EACrF;AACJ;"}

package/pow-block-DI5ICzhc.js

@@ -0,0 +1,13 @@
+const emitter = {
+  className: "PowBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const v = ctx.resolve(block, "value", stage, state);
+    const p = ctx.resolve(block, "power", stage, state);
+    const pc = ctx.cast(p, v.type).expr;
+    return { expr: `pow(${v.expr}, ${pc})`, type: v.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=pow-block-DI5ICzhc.js.map

package/pow-block-DI5ICzhc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pow-block-DI5ICzhc.js","sources":["../src/material/node/blocks/pow-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"PowBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const v = ctx.resolve(block, \"value\", stage, state);\n        const p = ctx.resolve(block, \"power\", stage, state);\n        const pc = ctx.cast(p, v.type).expr;\n        return { expr: `pow(${v.expr}, ${pc})`, type: v.type };\n    },\n};\n"],"names":[],"mappings":"AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,IAAI,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AAClD,UAAM,IAAI,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AAClD,UAAM,KAAK,IAAI,KAAK,GAAG,EAAE,IAAI,EAAE;AAC/B,WAAO,EAAE,MAAM,OAAO,EAAE,IAAI,KAAK,EAAE,KAAK,MAAM,EAAE,KAAA;AAAA,EACpD;AACJ;"}

package/random-number-block-2OyRYljF.js

@@ -0,0 +1,15 @@
+const emitter = {
+  className: "RandomNumberBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const seed = ctx.resolve(block, "seed", stage, state);
+    if (seed.type === "f32" || seed.type === "mat4f" || seed.type === "texture2d" || seed.type === "textureCube") {
+      throw new Error(`NodeMaterial: RandomNumberBlock requires a vector seed so Babylon.js getRand(seed.xy) can be emitted; got ${seed.type}`);
+    }
+    state[stage].helpers.set("nme_getRand", "fn nme_getRand(seed: vec2<f32>) -> f32 { return fract(sin(dot(seed.xy, vec2<f32>(12.9898, 78.233))) * 43758.5453); }");
+    return { expr: `nme_getRand((${seed.expr}).xy)`, type: "f32" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=random-number-block-2OyRYljF.js.map

package/random-number-block-2OyRYljF.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-number-block-2OyRYljF.js","sources":["../src/material/node/blocks/random-number-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"RandomNumberBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const seed = ctx.resolve(block, \"seed\", stage, state);\n        if (seed.type === \"f32\" || seed.type === \"mat4f\" || seed.type === \"texture2d\" || seed.type === \"textureCube\") {\n            throw new Error(`NodeMaterial: RandomNumberBlock requires a vector seed so Babylon.js getRand(seed.xy) can be emitted; got ${seed.type}`);\n        }\n        state[stage].helpers.set(\"nme_getRand\", \"fn nme_getRand(seed: vec2<f32>) -> f32 { return fract(sin(dot(seed.xy, vec2<f32>(12.9898, 78.233))) * 43758.5453); }\");\n        return { expr: `nme_getRand((${seed.expr}).xy)`, type: \"f32\" };\n    },\n};\n"],"names":[],"mappings":"AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,OAAO,IAAI,QAAQ,OAAO,QAAQ,OAAO,KAAK;AACpD,QAAI,KAAK,SAAS,SAAS,KAAK,SAAS,WAAW,KAAK,SAAS,eAAe,KAAK,SAAS,eAAe;AAC1G,YAAM,IAAI,MAAM,6GAA6G,KAAK,IAAI,EAAE;AAAA,IAC5I;AACA,UAAM,KAAK,EAAE,QAAQ,IAAI,eAAe,sHAAsH;AAC9J,WAAO,EAAE,MAAM,gBAAgB,KAAK,IAAI,SAAS,MAAM,MAAA;AAAA,EAC3D;AACJ;"}

package/reciprocal-block-Ck3CW-j-.js

@@ -0,0 +1,14 @@
+const emitter = {
+  className: "ReciprocalBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const input = ctx.resolve(block, "input", stage, state);
+    if (input.type === "mat4f") {
+      return { expr: `inverse(${input.expr})`, type: "mat4f" };
+    }
+    return { expr: `(1.0 / ${input.expr})`, type: input.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=reciprocal-block-Ck3CW-j-.js.map

package/reciprocal-block-Ck3CW-j-.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reciprocal-block-Ck3CW-j-.js","sources":["../src/material/node/blocks/reciprocal-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"ReciprocalBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const input = ctx.resolve(block, \"input\", stage, state);\n        if (input.type === \"mat4f\") {\n            return { expr: `inverse(${input.expr})`, type: \"mat4f\" };\n        }\n        return { expr: `(1.0 / ${input.expr})`, type: input.type };\n    },\n};\n"],"names":[],"mappings":"AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,QAAQ,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AACtD,QAAI,MAAM,SAAS,SAAS;AACxB,aAAO,EAAE,MAAM,WAAW,MAAM,IAAI,KAAK,MAAM,QAAA;AAAA,IACnD;AACA,WAAO,EAAE,MAAM,UAAU,MAAM,IAAI,KAAK,MAAM,MAAM,KAAA;AAAA,EACxD;AACJ;"}

package/reflect-block-CizpzrX4.js

@@ -0,0 +1,12 @@
+const emitter = {
+  className: "ReflectBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const incident = ctx.cast(ctx.resolve(block, "incident", stage, state), "vec3f").expr;
+    const normal = ctx.cast(ctx.resolve(block, "normal", stage, state), "vec3f").expr;
+    return { expr: `reflect(${incident}, ${normal})`, type: "vec3f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=reflect-block-CizpzrX4.js.map

package/reflect-block-CizpzrX4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflect-block-CizpzrX4.js","sources":["../src/material/node/blocks/reflect-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"ReflectBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const incident = ctx.cast(ctx.resolve(block, \"incident\", stage, state), \"vec3f\").expr;\n        const normal = ctx.cast(ctx.resolve(block, \"normal\", stage, state), \"vec3f\").expr;\n        return { expr: `reflect(${incident}, ${normal})`, type: \"vec3f\" };\n    },\n};\n"],"names":[],"mappings":"AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,WAAW,IAAI,KAAK,IAAI,QAAQ,OAAO,YAAY,OAAO,KAAK,GAAG,OAAO,EAAE;AACjF,UAAM,SAAS,IAAI,KAAK,IAAI,QAAQ,OAAO,UAAU,OAAO,KAAK,GAAG,OAAO,EAAE;AAC7E,WAAO,EAAE,MAAM,WAAW,QAAQ,KAAK,MAAM,KAAK,MAAM,QAAA;AAAA,EAC5D;AACJ;"}

package/reflectance-fragment-BCrgPmrt.js

@@ -0,0 +1,143 @@
+import { aq as PBR_HAS_METALLIC_REFLECTANCE_MAP, ar as PBR_HAS_REFLECTANCE_MAP, as as PBR2_HAS_REFLECTANCE_FACTORS, at as PBR2_HAS_UV2, au as PBR_HAS_USE_ALPHA_ONLY_MR } from "./index-C8HOR2sB.js";
+const STAGE_FRAGMENT = 2;
+function writeReflectanceUBO(data, material, offsets) {
+  if (!offsets.has("occlusionStrength")) {
+    return;
+  }
+  const off = offsets.get("occlusionStrength") / 4;
+  data[off] = material.occlusionStrength ?? 1;
+  data[off + 1] = material.metallicF0Factor ?? 1;
+  data[off + 2] = material.specularWeight ?? material.metallicF0Factor ?? 1;
+  const mrc = material.metallicReflectanceColor;
+  data[off + 4] = mrc ? mrc[0] : 1;
+  data[off + 5] = mrc ? mrc[1] : 1;
+  data[off + 6] = mrc ? mrc[2] : 1;
+}
+function createReflectanceFragment(hasMetallicReflectanceMap, hasReflectanceMap, useAlphaOnlyMR, hasOcclusionUv2 = false) {
+  const bindings = [];
+  if (hasMetallicReflectanceMap) {
+    bindings.push(
+      { _name: "metallicReflectanceMap", _type: { _kind: "texture", _textureType: "texture_2d<f32>" }, _visibility: STAGE_FRAGMENT },
+      { _name: "metallicReflectanceMapSampler", _type: { _kind: "sampler", _samplerType: "sampler" }, _visibility: STAGE_FRAGMENT }
+    );
+  }
+  if (hasReflectanceMap) {
+    bindings.push(
+      { _name: "reflectanceMap", _type: { _kind: "texture", _textureType: "texture_2d<f32>" }, _visibility: STAGE_FRAGMENT },
+      { _name: "reflectanceMapSampler", _type: { _kind: "sampler", _samplerType: "sampler" }, _visibility: STAGE_FRAGMENT }
+    );
+  }
+  let f0Code = `var mrFactors = vec4<f32>(material.metallicReflectanceColor, material.metallicF0Factor);
+var specularWeight = material.specularWeight;`;
+  if (hasReflectanceMap) {
+    f0Code += `
+{ let rSample = textureSample(reflectanceMap, reflectanceMapSampler, input.uv);
+  let rLinear = pow(rSample.rgb, vec3<f32>(2.2));
+  mrFactors = vec4<f32>(mrFactors.rgb * rLinear, mrFactors.a); }`;
+  }
+  if (hasMetallicReflectanceMap) {
+    if (!useAlphaOnlyMR) {
+      f0Code += `
+{ let mrSample = textureSample(metallicReflectanceMap, metallicReflectanceMapSampler, input.uv);
+  let mrLinear = pow(mrSample.rgb, vec3<f32>(2.2));
+  mrFactors = vec4<f32>(mrFactors.rgb * mrLinear, mrFactors.a * mrSample.a);
+  specularWeight *= mrSample.a; }`;
+    } else {
+      f0Code += `
+{ let mrSample = textureSample(metallicReflectanceMap, metallicReflectanceMapSampler, input.uv);
+  mrFactors = vec4<f32>(mrFactors.rgb, mrFactors.a * mrSample.a);
+  specularWeight *= mrSample.a; }`;
+    }
+  }
+  f0Code += `
+let dielectricF0 = material.reflectance * mrFactors.a;
+let surfaceReflectivityColor = mrFactors.rgb;
+let dielectricColorF0 = vec3<f32>(dielectricF0) * surfaceReflectivityColor;
+let metallicColorF0 = baseColor;
+var colorF0 = mix(dielectricColorF0, metallicColorF0, metallic);
+let colorF90 = vec3<f32>(mix(specularWeight, 1.0, metallic));
+let surfaceAlbedo = baseColor * (vec3<f32>(1.0) - vec3<f32>(dielectricF0) * surfaceReflectivityColor) * (1.0 - metallic);`;
+  return {
+    _id: "reflectance",
+    _uboFields: [
+      { _name: "occlusionStrength", _type: "f32" },
+      { _name: "metallicF0Factor", _type: "f32" },
+      { _name: "specularWeight", _type: "f32" },
+      { _name: "_mrPad1", _type: "f32" },
+      { _name: "metallicReflectanceColor", _type: "vec3<f32>" },
+      { _name: "_mrPad2", _type: "f32" }
+    ],
+    _bindings: bindings,
+    _fragmentSlots: {
+      MF: f0Code,
+      AT: hasOcclusionUv2 ? `let occlusion = mix(1.0, textureSample(occlusionTexture, occlusionSampler_, input.uv2).r, material.occlusionStrength);` : `let occlusion = mix(1.0, orm.r, material.occlusionStrength);`
+    }
+  };
+}
+const pbrExt = {
+  id: "reflectance",
+  phase: "fragment",
+  detect(mat) {
+    const m = mat;
+    let f = 0;
+    let f2 = 0;
+    if (m.metallicReflectanceTexture) {
+      f |= PBR_HAS_METALLIC_REFLECTANCE_MAP;
+    }
+    if (m.reflectanceTexture) {
+      f |= PBR_HAS_REFLECTANCE_MAP;
+    }
+    if (f === 0) {
+      const hasNonDefaultF0 = m.metallicF0Factor != null && Math.abs(m.metallicF0Factor - 1) > 1e-6;
+      const mrc = m.metallicReflectanceColor;
+      const hasNonDefaultColor = mrc != null && (mrc[0] !== 1 || mrc[1] !== 1 || mrc[2] !== 1);
+      if (hasNonDefaultF0 || hasNonDefaultColor) {
+        f2 |= PBR2_HAS_REFLECTANCE_FACTORS;
+      }
+    }
+    if ((f !== 0 || f2 & PBR2_HAS_REFLECTANCE_FACTORS) && m.useOnlyMetallicFromMetallicReflectanceTexture) {
+      f |= PBR_HAS_USE_ALPHA_ONLY_MR;
+    }
+    return { f, f2 };
+  },
+  frag(ctx) {
+    const hasMR = (ctx._features & PBR_HAS_METALLIC_REFLECTANCE_MAP) !== 0;
+    const hasR = (ctx._features & PBR_HAS_REFLECTANCE_MAP) !== 0;
+    const hasFactors = (ctx._features2 & PBR2_HAS_REFLECTANCE_FACTORS) !== 0;
+    if (!hasMR && !hasR && !hasFactors) {
+      return null;
+    }
+    return createReflectanceFragment(hasMR, hasR, (ctx._features & PBR_HAS_USE_ALPHA_ONLY_MR) !== 0, (ctx._features2 & PBR2_HAS_UV2) !== 0);
+  },
+  writeUbo: writeReflectanceUBO,
+  bind(ctx, entries, b) {
+    if ((ctx._features & (PBR_HAS_METALLIC_REFLECTANCE_MAP | PBR_HAS_REFLECTANCE_MAP)) === 0) {
+      return b;
+    }
+    const m = ctx._material;
+    if (m.metallicReflectanceTexture) {
+      entries.push({ binding: b++, resource: m.metallicReflectanceTexture.view });
+      entries.push({ binding: b++, resource: m.metallicReflectanceTexture.sampler });
+    }
+    if (m.reflectanceTexture) {
+      entries.push({ binding: b++, resource: m.reflectanceTexture.view });
+      entries.push({ binding: b++, resource: m.reflectanceTexture.sampler });
+    }
+    return b;
+  },
+  textures(mat, t) {
+    const m = mat;
+    if (m.metallicReflectanceTexture) {
+      t.push(m.metallicReflectanceTexture);
+    }
+    if (m.reflectanceTexture) {
+      t.push(m.reflectanceTexture);
+    }
+  }
+};
+export {
+  createReflectanceFragment,
+  pbrExt,
+  writeReflectanceUBO
+};
+//# sourceMappingURL=reflectance-fragment-BCrgPmrt.js.map

package/reflectance-fragment-BCrgPmrt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflectance-fragment-BCrgPmrt.js","sources":["../src/material/pbr/fragments/reflectance-fragment.ts"],"sourcesContent":["/**\n * Metallic Reflectance Fragment\n *\n * Advanced F0 computation with metallicReflectanceTexture and/or reflectanceTexture.\n * Only bundled when a scene uses these textures.\n *\n * Provides: UBO fields (occlusionStrength, metallicF0Factor, specularWeight, metallicReflectanceColor),\n * conditional texture bindings, F0 computation, and occlusion handling.\n */\n\nimport type { ShaderFragment, BindingDecl } from \"../../../shader/fragment-types.js\";\nimport type { PbrMaterialProps } from \"../pbr-material.js\";\nimport type { PbrExt } from \"../pbr-flags.js\";\nimport { PBR_HAS_METALLIC_REFLECTANCE_MAP, PBR_HAS_REFLECTANCE_MAP, PBR_HAS_USE_ALPHA_ONLY_MR, PBR2_HAS_REFLECTANCE_FACTORS, PBR2_HAS_UV2 } from \"../pbr-flag-bits.js\";\n\n// WebGPU shader stage constants\nconst STAGE_FRAGMENT = 0x2;\n\n/** Write the reflectance-extension material-UBO slice\n *  (occlusionStrength, metallicF0Factor, specularWeight, metallicReflectanceColor).\n *  Gated by the presence of the `occlusionStrength` field in the UBO spec,\n *  which is added only when a metallic-reflectance or reflectance texture\n *  is in use. */\nexport function writeReflectanceUBO(data: Float32Array, material: PbrMaterialProps, offsets: ReadonlyMap<string, number>): void {\n    if (!offsets.has(\"occlusionStrength\")) {\n        return;\n    }\n    const off = offsets.get(\"occlusionStrength\")! / 4;\n    data[off] = material.occlusionStrength ?? 1.0;\n    data[off + 1] = material.metallicF0Factor ?? 1.0;\n    data[off + 2] = material.specularWeight ?? material.metallicF0Factor ?? 1.0;\n    const mrc = material.metallicReflectanceColor;\n    data[off + 4] = mrc ? mrc[0]! : 1.0;\n    data[off + 5] = mrc ? mrc[1]! : 1.0;\n    data[off + 6] = mrc ? mrc[2]! : 1.0;\n}\n\n/**\n * Create a metallic reflectance fragment.\n * @param hasMetallicReflectanceMap - Whether the material has a metallicReflectanceTexture.\n * @param hasReflectanceMap - Whether the material has a reflectanceTexture.\n * @param useAlphaOnlyMR - Whether to use only the alpha channel from the metallic reflectance map.\n */\nexport function createReflectanceFragment(\n    hasMetallicReflectanceMap: boolean,\n    hasReflectanceMap: boolean,\n    useAlphaOnlyMR: boolean,\n    hasOcclusionUv2: boolean = false\n): ShaderFragment {\n    const bindings: BindingDecl[] = [];\n    if (hasMetallicReflectanceMap) {\n        bindings.push(\n            { _name: \"metallicReflectanceMap\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"metallicReflectanceMapSampler\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT }\n        );\n    }\n    if (hasReflectanceMap) {\n        bindings.push(\n            { _name: \"reflectanceMap\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"reflectanceMapSampler\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT }\n        );\n    }\n\n    // Build F0 computation code\n    let f0Code = `var mrFactors = vec4<f32>(material.metallicReflectanceColor, material.metallicF0Factor);\nvar specularWeight = material.specularWeight;`;\n    if (hasReflectanceMap) {\n        f0Code += `\n{ let rSample = textureSample(reflectanceMap, reflectanceMapSampler, input.uv);\n  let rLinear = pow(rSample.rgb, vec3<f32>(2.2));\n  mrFactors = vec4<f32>(mrFactors.rgb * rLinear, mrFactors.a); }`;\n    }\n    if (hasMetallicReflectanceMap) {\n        if (!useAlphaOnlyMR) {\n            f0Code += `\n{ let mrSample = textureSample(metallicReflectanceMap, metallicReflectanceMapSampler, input.uv);\n  let mrLinear = pow(mrSample.rgb, vec3<f32>(2.2));\n  mrFactors = vec4<f32>(mrFactors.rgb * mrLinear, mrFactors.a * mrSample.a);\n  specularWeight *= mrSample.a; }`;\n        } else {\n            f0Code += `\n{ let mrSample = textureSample(metallicReflectanceMap, metallicReflectanceMapSampler, input.uv);\n  mrFactors = vec4<f32>(mrFactors.rgb, mrFactors.a * mrSample.a);\n  specularWeight *= mrSample.a; }`;\n        }\n    }\n    f0Code += `\nlet dielectricF0 = material.reflectance * mrFactors.a;\nlet surfaceReflectivityColor = mrFactors.rgb;\nlet dielectricColorF0 = vec3<f32>(dielectricF0) * surfaceReflectivityColor;\nlet metallicColorF0 = baseColor;\nvar colorF0 = mix(dielectricColorF0, metallicColorF0, metallic);\nlet colorF90 = vec3<f32>(mix(specularWeight, 1.0, metallic));\nlet surfaceAlbedo = baseColor * (vec3<f32>(1.0) - vec3<f32>(dielectricF0) * surfaceReflectivityColor) * (1.0 - metallic);`;\n\n    return {\n        _id: \"reflectance\",\n\n        _uboFields: [\n            { _name: \"occlusionStrength\", _type: \"f32\" },\n            { _name: \"metallicF0Factor\", _type: \"f32\" },\n            { _name: \"specularWeight\", _type: \"f32\" },\n            { _name: \"_mrPad1\", _type: \"f32\" },\n            { _name: \"metallicReflectanceColor\", _type: \"vec3<f32>\" },\n            { _name: \"_mrPad2\", _type: \"f32\" },\n        ],\n\n        _bindings: bindings,\n\n        _fragmentSlots: {\n            MF: f0Code,\n            AT: hasOcclusionUv2\n                ? `let occlusion = mix(1.0, textureSample(occlusionTexture, occlusionSampler_, input.uv2).r, material.occlusionStrength);`\n                : `let occlusion = mix(1.0, orm.r, material.occlusionStrength);`,\n        },\n    };\n}\n\n/** Create the reflectance PBR extension (group 1, fragment phase). */\nexport const pbrExt: PbrExt = {\n    id: \"reflectance\",\n    phase: \"fragment\",\n    detect(mat) {\n        const m = mat as PbrMaterialProps;\n        let f = 0;\n        let f2 = 0;\n        if (m.metallicReflectanceTexture) {\n            f |= PBR_HAS_METALLIC_REFLECTANCE_MAP;\n        }\n        if (m.reflectanceTexture) {\n            f |= PBR_HAS_REFLECTANCE_MAP;\n        }\n        if (f === 0) {\n            const hasNonDefaultF0 = m.metallicF0Factor != null && Math.abs(m.metallicF0Factor - 1) > 1e-6;\n            const mrc = m.metallicReflectanceColor;\n            const hasNonDefaultColor = mrc != null && (mrc[0] !== 1 || mrc[1] !== 1 || mrc[2] !== 1);\n            if (hasNonDefaultF0 || hasNonDefaultColor) {\n                f2 |= PBR2_HAS_REFLECTANCE_FACTORS;\n            }\n        }\n        if ((f !== 0 || f2 & PBR2_HAS_REFLECTANCE_FACTORS) && m.useOnlyMetallicFromMetallicReflectanceTexture) {\n            f |= PBR_HAS_USE_ALPHA_ONLY_MR;\n        }\n        return { f, f2 };\n    },\n    frag(ctx) {\n        const hasMR = (ctx._features & PBR_HAS_METALLIC_REFLECTANCE_MAP) !== 0;\n        const hasR = (ctx._features & PBR_HAS_REFLECTANCE_MAP) !== 0;\n        const hasFactors = (ctx._features2 & PBR2_HAS_REFLECTANCE_FACTORS) !== 0;\n        if (!hasMR && !hasR && !hasFactors) {\n            return null;\n        }\n        return createReflectanceFragment(hasMR, hasR, (ctx._features & PBR_HAS_USE_ALPHA_ONLY_MR) !== 0, (ctx._features2 & PBR2_HAS_UV2) !== 0);\n    },\n    writeUbo: writeReflectanceUBO as PbrExt[\"writeUbo\"],\n    bind(ctx, entries, b) {\n        if ((ctx._features & (PBR_HAS_METALLIC_REFLECTANCE_MAP | PBR_HAS_REFLECTANCE_MAP)) === 0) {\n            return b;\n        }\n        const m = ctx._material as PbrMaterialProps;\n        if (m.metallicReflectanceTexture) {\n            entries.push({ binding: b++, resource: m.metallicReflectanceTexture.view });\n            entries.push({ binding: b++, resource: m.metallicReflectanceTexture.sampler });\n        }\n        if (m.reflectanceTexture) {\n            entries.push({ binding: b++, resource: m.reflectanceTexture.view });\n            entries.push({ binding: b++, resource: m.reflectanceTexture.sampler });\n        }\n        return b;\n    },\n    textures(mat, t) {\n        const m = mat as PbrMaterialProps;\n        if (m.metallicReflectanceTexture) {\n            t.push(m.metallicReflectanceTexture);\n        }\n        if (m.reflectanceTexture) {\n            t.push(m.reflectanceTexture);\n        }\n    },\n};\n"],"names":[],"mappings":"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"}

package/reflection-block-DqcwyYqr.js

@@ -0,0 +1,12 @@
+const emitter = {
+  className: "ReflectionBlock",
+  stage: "fragment",
+  emit(_block, _outputName, _stage, state, _ctx) {
+    state.usesEnv = true;
+    return { expr: `vec3<f32>(0.0)`, type: "vec3f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=reflection-block-DqcwyYqr.js.map

package/reflection-block-DqcwyYqr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflection-block-DqcwyYqr.js","sources":["../src/material/node/blocks/reflection-block.ts"],"sourcesContent":["/** ReflectionBlock — marker that activates env IBL plumbing.\n *\n *  In the current Lite NME implementation the actual reflection sampling is\n *  performed inside `PBRMetallicRoughnessBlock` (which can address the env\n *  bindings directly). ReflectionBlock therefore plays a dual role:\n *    1. Sets `state.usesEnv = true` so the pipeline allocates env bindings\n *       and the scene UBO is extended.\n *    2. Provides a placeholder vec3 output (always zero) so any consumer\n *       wiring still compiles. PBR-MR ignores the actual value — it only\n *       checks whether the input is connected.\n *\n *  Future scenes that introduce non-PBR reflection paths (e.g. custom\n *  reflection passed to ColorSplitter for visualisation) will extend this\n *  emitter to actually sample the cubemap and emit a real RGB value.\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"ReflectionBlock\",\n    stage: \"fragment\",\n    emit(_block, _outputName, _stage, state, _ctx) {\n        state.usesEnv = true;\n        return { expr: `vec3<f32>(0.0)`, type: \"vec3f\" };\n    },\n};\n"],"names":[],"mappings":"AAkBO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,QAAQ,aAAa,QAAQ,OAAO,MAAM;AAC3C,UAAM,UAAU;AAChB,WAAO,EAAE,MAAM,kBAAkB,MAAM,QAAA;AAAA,EAC3C;AACJ;"}

package/reflection-texture-base-block-1xmJ0HDj.js

@@ -0,0 +1,10 @@
+const emitter = {
+  className: "ReflectionTextureBaseBlock",
+  emit(block) {
+    throw new Error(`ReflectionTextureBaseBlock "${block.name}" is an abstract compatibility block and cannot be emitted directly.`);
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=reflection-texture-base-block-1xmJ0HDj.js.map

package/reflection-texture-base-block-1xmJ0HDj.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflection-texture-base-block-1xmJ0HDj.js","sources":["../src/material/node/blocks/reflection-texture-base-block.ts"],"sourcesContent":["/** ReflectionTextureBaseBlock compatibility registration.\n *\n * In Babylon.js this is a shared base class for concrete reflection blocks. It\n * has no usable standalone outputs in serialized editor graphs. Lite registers\n * it so snippets containing an unconnected compatibility/base block deserialize\n * cleanly, but surfaces a loud error if a graph attempts to emit it directly.\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"ReflectionTextureBaseBlock\",\n    emit(block): never {\n        throw new Error(`ReflectionTextureBaseBlock \"${block.name}\" is an abstract compatibility block and cannot be emitted directly.`);\n    },\n};\n"],"names":[],"mappings":"AAUO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAc;AACf,UAAM,IAAI,MAAM,+BAA+B,MAAM,IAAI,sEAAsE;AAAA,EACnI;AACJ;"}

package/reflection-texture-block-C3QtzoV8.js

@@ -0,0 +1,60 @@
+const EQUIRECTANGULAR_MODE = 7;
+const RECIPROCAL_PI2 = "0.15915494309189535";
+const RECIPROCAL_PI = "0.3183098861837907";
+function sanitize(name) {
+  return name.replace(/[^A-Za-z0-9_]/g, "_");
+}
+const OUTPUTS = {
+  rgb: { swizzle: "", type: "vec3f" },
+  r: { swizzle: ".x", type: "f32" },
+  g: { swizzle: ".y", type: "f32" },
+  b: { swizzle: ".z", type: "f32" }
+};
+const emitter = {
+  className: "ReflectionTextureBlock",
+  stage: "fragment",
+  emit(block, outputName, stage, state, ctx) {
+    var _a, _b, _c;
+    const mode = block.serialized["coordinatesMode"] ?? EQUIRECTANGULAR_MODE;
+    if (mode !== EQUIRECTANGULAR_MODE) {
+      throw new Error(`ReflectionTextureBlock: coordinatesMode ${mode} not supported (only EQUIRECTANGULAR_MODE=7)`);
+    }
+    const bindingName = sanitize(block.name || `reflection${block.id}`);
+    if (!state.textures.find((t) => t.name === bindingName)) {
+      state.textures.push({ name: bindingName, kind: "texture2d", texture: null });
+    }
+    const memoKey = `_refl_${block.id}_rgb`;
+    let sample = state.fragment.memo.get(memoKey);
+    if (!sample) {
+      const wp = ((_a = block.inputs.get("worldPosition")) == null ? void 0 : _a.source) ? ctx.cast(ctx.resolve(block, "worldPosition", stage, state), "vec3f").expr : `vec3<f32>(0.0)`;
+      const wn = ((_b = block.inputs.get("worldNormal")) == null ? void 0 : _b.source) ? ctx.cast(ctx.resolve(block, "worldNormal", stage, state), "vec3f").expr : `vec3<f32>(0.0, 1.0, 0.0)`;
+      const cp = ((_c = block.inputs.get("cameraPosition")) == null ? void 0 : _c.source) ? ctx.cast(ctx.resolve(block, "cameraPosition", stage, state), "vec3f").expr : `_NME_CAMERA_POS_`;
+      const t = ctx.temp(state, "refl");
+      const body = [
+        `let _v${t} = normalize(${cp} - ${wp});`,
+        `let _r${t} = reflect(-_v${t}, normalize(${wn}));`,
+        // BJS flips the V coordinate after computing equirectangular UVs.
+        `let _uv${t} = vec2<f32>(atan2(_r${t}.z, _r${t}.x) * ${RECIPROCAL_PI2} + 0.5, 1.0 - acos(clamp(_r${t}.y, -1.0, 1.0)) * ${RECIPROCAL_PI});`,
+        `let _s${t} = textureSample(nodeTex_${bindingName}, nodeSamp_${bindingName}, _uv${t});`
+      ];
+      state.fragment.body.push(body.join("\n"));
+      sample = { expr: `_s${t}.xyz`, type: "vec3f" };
+      state.fragment.memo.set(memoKey, sample);
+    }
+    if (outputName === "a") {
+      return { expr: "1.0", type: "f32" };
+    }
+    if (outputName === "reflectionCoords") {
+      return { expr: sample.expr, type: "vec3f" };
+    }
+    const out = OUTPUTS[outputName] ?? OUTPUTS.rgb;
+    if (out.swizzle === "") {
+      return sample;
+    }
+    return { expr: `${sample.expr}${out.swizzle}`, type: out.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=reflection-texture-block-C3QtzoV8.js.map

package/reflection-texture-block-C3QtzoV8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflection-texture-block-C3QtzoV8.js","sources":["../src/material/node/blocks/reflection-texture-block.ts"],"sourcesContent":["/** ReflectionTextureBlock — environment reflection sampling.\n *\n *  Inputs: `position` (local-space), `worldPosition`, `worldNormal`, `world`\n *  (mat4), `cameraPosition`, `view` (mat4).\n *  Outputs: `rgb` (vec3), `r`/`g`/`b`/`a` (f32), `reflectionCoords` (vec3).\n *\n *  Current support: coordinatesMode = EQUIRECTANGULAR_MODE (7) with a 2D input\n *  texture. Other modes (CUBIC, SPHERICAL, PLANAR, PROJECTION, SKYBOX,\n *  EQUIRECTANGULAR_FIXED) throw at parse-time so the failure is loud.\n *\n *  The embedded texture data (base64 PNG in the snippet) is decoded by the\n *  scene side and supplied via `parseNodeMaterialFromSnippet(..., { textures })`\n *  using the block's sanitized name as the key — same pattern as TextureBlock.\n *\n *  Gamma handling: when `gammaSpace: true` (typical for PNG environments stored\n *  in sRGB), the sampled colour is linearized via `pow(rgb, 2.2)` before being\n *  exposed on the `rgb`/`r`/`g`/`b` outputs.\n */\n\nimport type { BlockEmitter, NodeExpr } from \"../node-types.js\";\n\nconst EQUIRECTANGULAR_MODE = 7;\n\nconst RECIPROCAL_PI2 = \"0.15915494309189535\";\nconst RECIPROCAL_PI = \"0.3183098861837907\";\n\nfunction sanitize(name: string): string {\n    return name.replace(/[^A-Za-z0-9_]/g, \"_\");\n}\n\nconst OUTPUTS: Record<string, { swizzle: string; type: \"vec3f\" | \"f32\" }> = {\n    rgb: { swizzle: \"\", type: \"vec3f\" },\n    r: { swizzle: \".x\", type: \"f32\" },\n    g: { swizzle: \".y\", type: \"f32\" },\n    b: { swizzle: \".z\", type: \"f32\" },\n};\n\nexport const emitter: BlockEmitter = {\n    className: \"ReflectionTextureBlock\",\n    stage: \"fragment\",\n    emit(block, outputName, stage, state, ctx) {\n        const mode = (block.serialized[\"coordinatesMode\"] as number | undefined) ?? EQUIRECTANGULAR_MODE;\n        if (mode !== EQUIRECTANGULAR_MODE) {\n            throw new Error(`ReflectionTextureBlock: coordinatesMode ${mode} not supported (only EQUIRECTANGULAR_MODE=7)`);\n        }\n\n        const bindingName = sanitize(block.name || `reflection${block.id}`);\n        if (!state.textures.find((t) => t.name === bindingName)) {\n            state.textures.push({ name: bindingName, kind: \"texture2d\", texture: null });\n        }\n\n        const memoKey = `_refl_${block.id}_rgb`;\n        let sample = state.fragment.memo.get(memoKey);\n        if (!sample) {\n            const wp = block.inputs.get(\"worldPosition\")?.source ? ctx.cast(ctx.resolve(block, \"worldPosition\", stage, state), \"vec3f\").expr : `vec3<f32>(0.0)`;\n            const wn = block.inputs.get(\"worldNormal\")?.source ? ctx.cast(ctx.resolve(block, \"worldNormal\", stage, state), \"vec3f\").expr : `vec3<f32>(0.0, 1.0, 0.0)`;\n            const cp = block.inputs.get(\"cameraPosition\")?.source ? ctx.cast(ctx.resolve(block, \"cameraPosition\", stage, state), \"vec3f\").expr : `_NME_CAMERA_POS_`;\n\n            const t = ctx.temp(state, \"refl\");\n            const body: string[] = [\n                `let _v${t} = normalize(${cp} - ${wp});`,\n                `let _r${t} = reflect(-_v${t}, normalize(${wn}));`,\n                // BJS flips the V coordinate after computing equirectangular UVs.\n                `let _uv${t} = vec2<f32>(atan2(_r${t}.z, _r${t}.x) * ${RECIPROCAL_PI2} + 0.5, 1.0 - acos(clamp(_r${t}.y, -1.0, 1.0)) * ${RECIPROCAL_PI});`,\n                `let _s${t} = textureSample(nodeTex_${bindingName}, nodeSamp_${bindingName}, _uv${t});`,\n            ];\n            // BJS's NME ReflectionTextureBlock does NOT apply gamma conversion\n            // in the shader — it samples and uses raw values regardless of gammaSpace.\n            // The NME expression graph operates in gamma space (textures are non-sRGB),\n            // so the reflection must stay in gamma space too.\n            state.fragment.body.push(body.join(\"\\n\"));\n            sample = { expr: `_s${t}.xyz`, type: \"vec3f\" };\n            state.fragment.memo.set(memoKey, sample);\n        }\n\n        if (outputName === \"a\") {\n            return { expr: \"1.0\", type: \"f32\" };\n        }\n        if (outputName === \"reflectionCoords\") {\n            // Seldom used by graphs; return the reflection vector as a placeholder.\n            return { expr: sample.expr, type: \"vec3f\" };\n        }\n        const out = OUTPUTS[outputName] ?? OUTPUTS.rgb!;\n        if (out.swizzle === \"\") {\n            return sample as NodeExpr;\n        }\n        return { expr: `${sample.expr}${out.swizzle}`, type: out.type };\n    },\n};\n"],"names":[],"mappings":"AAqBA,MAAM,uBAAuB;AAE7B,MAAM,iBAAiB;AACvB,MAAM,gBAAgB;AAEtB,SAAS,SAAS,MAAsB;AACpC,SAAO,KAAK,QAAQ,kBAAkB,GAAG;AAC7C;AAEA,MAAM,UAAsE;AAAA,EACxE,KAAK,EAAE,SAAS,IAAI,MAAM,QAAA;AAAA,EAC1B,GAAG,EAAE,SAAS,MAAM,MAAM,MAAA;AAAA,EAC1B,GAAG,EAAE,SAAS,MAAM,MAAM,MAAA;AAAA,EAC1B,GAAG,EAAE,SAAS,MAAM,MAAM,MAAA;AAC9B;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,OAAO,YAAY,OAAO,OAAO,KAAK;AAnB/C;AAoBQ,UAAM,OAAQ,MAAM,WAAW,iBAAiB,KAA4B;AAC5E,QAAI,SAAS,sBAAsB;AAC/B,YAAM,IAAI,MAAM,2CAA2C,IAAI,8CAA8C;AAAA,IACjH;AAEA,UAAM,cAAc,SAAS,MAAM,QAAQ,aAAa,MAAM,EAAE,EAAE;AAClE,QAAI,CAAC,MAAM,SAAS,KAAK,CAAC,MAAM,EAAE,SAAS,WAAW,GAAG;AACrD,YAAM,SAAS,KAAK,EAAE,MAAM,aAAa,MAAM,aAAa,SAAS,MAAM;AAAA,IAC/E;AAEA,UAAM,UAAU,SAAS,MAAM,EAAE;AACjC,QAAI,SAAS,MAAM,SAAS,KAAK,IAAI,OAAO;AAC5C,QAAI,CAAC,QAAQ;AACT,YAAM,OAAK,WAAM,OAAO,IAAI,eAAe,MAAhC,mBAAmC,UAAS,IAAI,KAAK,IAAI,QAAQ,OAAO,iBAAiB,OAAO,KAAK,GAAG,OAAO,EAAE,OAAO;AACnI,YAAM,OAAK,WAAM,OAAO,IAAI,aAAa,MAA9B,mBAAiC,UAAS,IAAI,KAAK,IAAI,QAAQ,OAAO,eAAe,OAAO,KAAK,GAAG,OAAO,EAAE,OAAO;AAC/H,YAAM,OAAK,WAAM,OAAO,IAAI,gBAAgB,MAAjC,mBAAoC,UAAS,IAAI,KAAK,IAAI,QAAQ,OAAO,kBAAkB,OAAO,KAAK,GAAG,OAAO,EAAE,OAAO;AAErI,YAAM,IAAI,IAAI,KAAK,OAAO,MAAM;AAChC,YAAM,OAAiB;AAAA,QACnB,SAAS,CAAC,gBAAgB,EAAE,MAAM,EAAE;AAAA,QACpC,SAAS,CAAC,iBAAiB,CAAC,eAAe,EAAE;AAAA;AAAA,QAE7C,UAAU,CAAC,wBAAwB,CAAC,SAAS,CAAC,SAAS,cAAc,8BAA8B,CAAC,qBAAqB,aAAa;AAAA,QACtI,SAAS,CAAC,4BAA4B,WAAW,cAAc,WAAW,QAAQ,CAAC;AAAA,MAAA;AAMvF,YAAM,SAAS,KAAK,KAAK,KAAK,KAAK,IAAI,CAAC;AACxC,eAAS,EAAE,MAAM,KAAK,CAAC,QAAQ,MAAM,QAAA;AACrC,YAAM,SAAS,KAAK,IAAI,SAAS,MAAM;AAAA,IAC3C;AAEA,QAAI,eAAe,KAAK;AACpB,aAAO,EAAE,MAAM,OAAO,MAAM,MAAA;AAAA,IAChC;AACA,QAAI,eAAe,oBAAoB;AAEnC,aAAO,EAAE,MAAM,OAAO,MAAM,MAAM,QAAA;AAAA,IACtC;AACA,UAAM,MAAM,QAAQ,UAAU,KAAK,QAAQ;AAC3C,QAAI,IAAI,YAAY,IAAI;AACpB,aAAO;AAAA,IACX;AACA,WAAO,EAAE,MAAM,GAAG,OAAO,IAAI,GAAG,IAAI,OAAO,IAAI,MAAM,IAAI,KAAA;AAAA,EAC7D;AACJ;"}

package/refract-block-HHiAk-7U.js

@@ -0,0 +1,13 @@
+const emitter = {
+  className: "RefractBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const incident = ctx.cast(ctx.resolve(block, "incident", stage, state), "vec3f").expr;
+    const normal = ctx.cast(ctx.resolve(block, "normal", stage, state), "vec3f").expr;
+    const ior = ctx.cast(ctx.resolve(block, "ior", stage, state), "f32").expr;
+    return { expr: `refract(${incident}, ${normal}, ${ior})`, type: "vec3f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=refract-block-HHiAk-7U.js.map

package/refract-block-HHiAk-7U.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refract-block-HHiAk-7U.js","sources":["../src/material/node/blocks/refract-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"RefractBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const incident = ctx.cast(ctx.resolve(block, \"incident\", stage, state), \"vec3f\").expr;\n        const normal = ctx.cast(ctx.resolve(block, \"normal\", stage, state), \"vec3f\").expr;\n        const ior = ctx.cast(ctx.resolve(block, \"ior\", stage, state), \"f32\").expr;\n        return { expr: `refract(${incident}, ${normal}, ${ior})`, type: \"vec3f\" };\n    },\n};\n"],"names":[],"mappings":"AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,WAAW,IAAI,KAAK,IAAI,QAAQ,OAAO,YAAY,OAAO,KAAK,GAAG,OAAO,EAAE;AACjF,UAAM,SAAS,IAAI,KAAK,IAAI,QAAQ,OAAO,UAAU,OAAO,KAAK,GAAG,OAAO,EAAE;AAC7E,UAAM,MAAM,IAAI,KAAK,IAAI,QAAQ,OAAO,OAAO,OAAO,KAAK,GAAG,KAAK,EAAE;AACrE,WAAO,EAAE,MAAM,WAAW,QAAQ,KAAK,MAAM,KAAK,GAAG,KAAK,MAAM,QAAA;AAAA,EACpE;AACJ;"}

package/refraction-block-U8y6XiXs.js

@@ -0,0 +1,11 @@
+const emitter = {
+  className: "RefractionBlock",
+  stage: "fragment",
+  emit(_block, _outputName, _stage, _state, _ctx) {
+    return { expr: `vec3<f32>(0.0)`, type: "vec3f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=refraction-block-U8y6XiXs.js.map

package/refraction-block-U8y6XiXs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refraction-block-U8y6XiXs.js","sources":["../src/material/node/blocks/refraction-block.ts"],"sourcesContent":["/** RefractionBlock — passthrough marker.\n *  Refraction math (refract(V,N,eta), env LOD sampling, Beer-Lambert tint)\n *  is implemented inside PBRMetallicRoughnessBlock, which walks down through\n *  SubSurfaceBlock.refraction to read this block's intensity / tintAtDistance.\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"RefractionBlock\",\n    stage: \"fragment\",\n    emit(_block, _outputName, _stage, _state, _ctx) {\n        return { expr: `vec3<f32>(0.0)`, type: \"vec3f\" };\n    },\n};\n"],"names":[],"mappings":"AAQO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,QAAQ,aAAa,QAAQ,QAAQ,MAAM;AAC5C,WAAO,EAAE,MAAM,kBAAkB,MAAM,QAAA;AAAA,EAC3C;AACJ;"}

package/refraction-dispersion-wgsl-DdQCyyO1.js

@@ -0,0 +1,16 @@
+const DISPERSION_SAMPLE_WGSL = `let eta=material.refractionParams.y;
+let realIOR=1.0/eta;
+let spread=0.04*material.volumeParams.w*(realIOR-1.0);
+let etaR=1.0/(realIOR-spread);
+let etaB=1.0/(realIOR+spread);
+let cpR=scene.viewProjection*vec4<f32>(input.worldPos+refract(-V,N,etaR)*th,1.0);
+let cpG=scene.viewProjection*vec4<f32>(input.worldPos+refract(-V,N,eta)*th,1.0);
+let cpB=scene.viewProjection*vec4<f32>(input.worldPos+refract(-V,N,etaB)*th,1.0);
+let uvR=(cpR.xy/cpR.w)*vec2<f32>(0.5,-0.5)+vec2<f32>(0.5,0.5);
+let uvG=(cpG.xy/cpG.w)*vec2<f32>(0.5,-0.5)+vec2<f32>(0.5,0.5);
+let uvB=(cpB.xy/cpB.w)*vec2<f32>(0.5,-0.5)+vec2<f32>(0.5,0.5);
+let er=vec3<f32>(textureSampleLevel(refractionTexture,refractionSampler_,uvR,lv).r,textureSampleLevel(refractionTexture,refractionSampler_,uvG,lv).g,textureSampleLevel(refractionTexture,refractionSampler_,uvB,lv).b)*material.environmentIntensity;`;
+export {
+  DISPERSION_SAMPLE_WGSL
+};
+//# sourceMappingURL=refraction-dispersion-wgsl-DdQCyyO1.js.map