@luma.gl/shadertools 9.1.0-alpha.10 → 9.1.0-alpha.13

package/dist/index.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["index.js", "lib/utils/assert.js", "lib/filters/prop-types.js", "module-injectors.js", "lib/shader-assembly/shader-injections.js", "lib/shader-module/shader-module.js", "lib/shader-module/shader-module-dependencies.js", "lib/shader-assembly/platform-defines.js", "lib/shader-transpiler/transpile-glsl-shader.js", "lib/shader-assembly/shader-hooks.js", "lib/glsl-utils/get-shader-info.js", "lib/shader-assembly/assemble-shaders.js", "lib/preprocessor/preprocessor.js", "lib/shader-assembler.js", "lib/glsl-utils/shader-utils.js", "lib/shader-generator/utils/capitalize.js", "lib/shader-generator/glsl/generate-glsl.js", "lib/shader-generator/wgsl/generate-wgsl.js", "lib/shader-generator/generate-shader.js", "lib/wgsl/get-shader-layout-wgsl.js", "modules/math/fp16/fp16-utils.js", "modules/math/fp64/fp64-utils.js", "modules/math/random/random.js", "modules/math/fp32/fp32.js", "modules/engine/picking/picking.js", "modules/lighting/lights/lighting-uniforms-glsl.js", "modules/lighting/lights/lighting.js", "modules/lighting/no-material/dirlight.js", "modules/lighting/gouraud-material/gouraud-shaders-glsl.js", "modules/lighting/gouraud-material/gouraud-material.js", "modules/lighting/phong-material/phong-shaders-glsl.js", "modules/lighting/phong-material/phong-material.js", "modules/lighting/pbr-material/pbr-vertex-glsl.js", "modules/lighting/pbr-material/pbr-fragment-glsl.js", "modules/lighting/pbr-material/pbr-material.js", "modules/postprocessing/image-adjust-filters/brightnesscontrast.js", "modules/postprocessing/image-adjust-filters/denoise.js", "modules/postprocessing/image-adjust-filters/huesaturation.js", "modules/postprocessing/image-adjust-filters/noise.js", "modules/postprocessing/image-adjust-filters/sepia.js", "modules/postprocessing/image-adjust-filters/vibrance.js", "modules/postprocessing/image-adjust-filters/vignette.js", "modules/postprocessing/image-blur-filters/tiltshift.js", "modules/postprocessing/image-blur-filters/triangleblur.js", "modules/postprocessing/image-blur-filters/zoomblur.js", "modules/postprocessing/image-fun-filters/colorhalftone.js", "modules/postprocessing/image-fun-filters/dotscreen.js", "modules/postprocessing/image-fun-filters/edgework.js", "modules/postprocessing/image-fun-filters/hexagonalpixelate.js", "modules/postprocessing/image-fun-filters/ink.js", "modules/postprocessing/image-fun-filters/magnify.js", "modules/postprocessing/image-warp-filters/warp.js", "modules/postprocessing/image-warp-filters/bulgepinch.js", "modules/postprocessing/image-warp-filters/swirl.js", "modules/postprocessing/fxaa/fxaa.js", "modules-webgl1/math/fp64/fp64-arithmetic-glsl.js", "modules-webgl1/math/fp64/fp64-functions-glsl.js", "modules-webgl1/math/fp64/fp64.js", "modules-webgl1/geometry/geometry.js", "modules-webgl1/project/project.js", "modules-webgl1/lighting/lights/lights-glsl.js", "modules-webgl1/lighting/lights/lights.js", "modules-webgl1/lighting/dirlight/dirlight.js", "modules-webgl1/lighting/phong-lighting/phong-lighting-glsl.js", "modules-webgl1/lighting/phong-lighting/phong-lighting.js", "modules-webgl1/lighting/pbr/pbr-vertex-glsl.js", "modules-webgl1/lighting/pbr/pbr-fragment-glsl.js", "modules-webgl1/lighting/pbr/pbr.js"],
-  "sourcesContent": ["// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport { initializeShaderModule, initializeShaderModules } from \"./lib/shader-module/shader-module.js\";\nexport { getShaderModuleUniforms } from \"./lib/shader-module/shader-module.js\";\nexport { getShaderModuleDependencies } from \"./lib/shader-module/shader-module-dependencies.js\";\nexport { checkShaderModuleDeprecations } from \"./lib/shader-module/shader-module.js\";\nexport { getShaderModuleSource } from \"./lib/shader-assembly/assemble-shaders.js\";\nexport { resolveModules as _resolveModules } from \"./lib/shader-module/shader-module-dependencies.js\";\nexport { getDependencyGraph as _getDependencyGraph } from \"./lib/shader-module/shader-module-dependencies.js\";\n// ShaderAssembler\nexport { ShaderAssembler } from \"./lib/shader-assembler.js\";\n// SHADER HELPERS\n// Shader source introspection\nexport { getShaderInfo } from \"./lib/glsl-utils/get-shader-info.js\";\nexport { getQualifierDetails, getPassthroughFS, typeToChannelSuffix, typeToChannelCount, convertToVec4 } from \"./lib/glsl-utils/shader-utils.js\";\nexport { generateShaderForModule } from \"./lib/shader-generator/generate-shader.js\";\nexport { capitalize } from \"./lib/shader-generator/utils/capitalize.js\";\n// TEST EXPORTS - Do not use in production applications\nexport { preprocess } from \"./lib/preprocessor/preprocessor.js\";\nexport { assembleGLSLShaderPair } from \"./lib/shader-assembly/assemble-shaders.js\";\nexport { combineInjects } from \"./lib/shader-assembly/shader-injections.js\";\n// EXPERIMENTAL WGSL\nexport { getShaderLayoutFromWGSL } from \"./lib/wgsl/get-shader-layout-wgsl.js\";\n// data utils\nexport { toHalfFloat, fromHalfFloat } from \"./modules/math/fp16/fp16-utils.js\";\nexport { fp64ify, fp64LowPart, fp64ifyMatrix4 } from \"./modules/math/fp64/fp64-utils.js\";\n// math libraries\nexport { random } from \"./modules/math/random/random.js\";\nexport { fp32 } from \"./modules/math/fp32/fp32.js\";\nexport { picking } from \"./modules/engine/picking/picking.js\";\nexport { lighting } from \"./modules/lighting/lights/lighting.js\";\nexport { dirlight } from \"./modules/lighting/no-material/dirlight.js\";\nexport { gouraudMaterial } from \"./modules/lighting/gouraud-material/gouraud-material.js\";\nexport { phongMaterial } from \"./modules/lighting/phong-material/phong-material.js\";\n// export type {PBRMaterialSettings, PBRMaterialUniforms} from './modules/lighting/pbr-material/pbr';\nexport { pbrMaterial } from \"./modules/lighting/pbr-material/pbr-material.js\";\nexport { brightnessContrast } from \"./modules/postprocessing/image-adjust-filters/brightnesscontrast.js\";\nexport { denoise } from \"./modules/postprocessing/image-adjust-filters/denoise.js\";\nexport { hueSaturation } from \"./modules/postprocessing/image-adjust-filters/huesaturation.js\";\nexport { noise } from \"./modules/postprocessing/image-adjust-filters/noise.js\";\nexport { sepia } from \"./modules/postprocessing/image-adjust-filters/sepia.js\";\nexport { vibrance } from \"./modules/postprocessing/image-adjust-filters/vibrance.js\";\nexport { vignette } from \"./modules/postprocessing/image-adjust-filters/vignette.js\";\nexport { tiltShift } from \"./modules/postprocessing/image-blur-filters/tiltshift.js\";\nexport { triangleBlur } from \"./modules/postprocessing/image-blur-filters/triangleblur.js\";\nexport { zoomBlur } from \"./modules/postprocessing/image-blur-filters/zoomblur.js\";\nexport { colorHalftone } from \"./modules/postprocessing/image-fun-filters/colorhalftone.js\";\nexport { dotScreen } from \"./modules/postprocessing/image-fun-filters/dotscreen.js\";\nexport { edgeWork } from \"./modules/postprocessing/image-fun-filters/edgework.js\";\nexport { hexagonalPixelate } from \"./modules/postprocessing/image-fun-filters/hexagonalpixelate.js\";\nexport { ink } from \"./modules/postprocessing/image-fun-filters/ink.js\";\nexport { magnify } from \"./modules/postprocessing/image-fun-filters/magnify.js\";\nexport { bulgePinch } from \"./modules/postprocessing/image-warp-filters/bulgepinch.js\";\nexport { swirl } from \"./modules/postprocessing/image-warp-filters/swirl.js\";\n// Postprocessing modules\n// export type {FXAAProps, FXAAUniforms} from './modules/postprocessing/fxaa/fxaa';\nexport { fxaa } from \"./modules/postprocessing/fxaa/fxaa.js\";\nexport { warp as _warp } from \"./modules/postprocessing/image-warp-filters/warp.js\";\n// DEPRECATED - v8 legacy shader modules (non-uniform buffer)\n// math libraries\nexport { fp64, fp64arithmetic } from \"./modules-webgl1/math/fp64/fp64.js\";\n// projection and lighting\nexport { geometry as geometry1 } from \"./modules-webgl1/geometry/geometry.js\";\nexport { project as project1 } from \"./modules-webgl1/project/project.js\";\nexport { lights as lights1 } from \"./modules-webgl1/lighting/lights/lights.js\";\nexport { dirlight as dirlight1 } from \"./modules-webgl1/lighting/dirlight/dirlight.js\";\nexport { gouraudLighting, phongLighting } from \"./modules-webgl1/lighting/phong-lighting/phong-lighting.js\";\nexport { pbr } from \"./modules-webgl1/lighting/pbr/pbr.js\";\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// Recommendation is to ignore message but current test suite checks agains the\n// message so keep it for now.\nexport function assert(condition, message) {\n    if (!condition) {\n        throw new Error(message || 'shadertools: assertion failed.');\n    }\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { assert } from \"../utils/assert.js\";\n/** Minimal validators for number and array types */\nconst DEFAULT_PROP_VALIDATORS = {\n    number: {\n        type: 'number',\n        validate(value, propType) {\n            return (Number.isFinite(value) &&\n                typeof propType === 'object' &&\n                (propType.max === undefined || value <= propType.max) &&\n                (propType.min === undefined || value >= propType.min));\n        }\n    },\n    array: {\n        type: 'array',\n        validate(value, propType) {\n            return Array.isArray(value) || ArrayBuffer.isView(value);\n        }\n    }\n};\n/**\n * Parse a list of property types into property definitions that can be used to validate\n * values passed in by applications.\n * @param propTypes\n * @returns\n */\nexport function makePropValidators(propTypes) {\n    const propValidators = {};\n    for (const [name, propType] of Object.entries(propTypes)) {\n        propValidators[name] = makePropValidator(propType);\n    }\n    return propValidators;\n}\n/**\n * Validate a map of user supplied properties against a map of validators\n * Inject default values when user doesn't supply a property\n * @param properties\n * @param propValidators\n * @returns\n */\nexport function getValidatedProperties(properties, propValidators, errorMessage) {\n    const validated = {};\n    for (const [key, propsValidator] of Object.entries(propValidators)) {\n        if (properties && key in properties && !propsValidator.private) {\n            if (propsValidator.validate) {\n                assert(propsValidator.validate(properties[key], propsValidator), `${errorMessage}: invalid ${key}`);\n            }\n            validated[key] = properties[key];\n        }\n        else {\n            // property not supplied - use default value\n            validated[key] = propsValidator.value;\n        }\n    }\n    // TODO - warn for unused properties that don't match a validator?\n    return validated;\n}\n/**\n * Creates a property validator for a prop type. Either contains:\n * - a valid prop type object ({type, ...})\n * - or just a default value, in which case type and name inference is used\n */\nfunction makePropValidator(propType) {\n    let type = getTypeOf(propType);\n    if (type !== 'object') {\n        return { value: propType, ...DEFAULT_PROP_VALIDATORS[type], type };\n    }\n    // Special handling for objects\n    if (typeof propType === 'object') {\n        if (!propType) {\n            return { type: 'object', value: null };\n        }\n        if (propType.type !== undefined) {\n            return { ...propType, ...DEFAULT_PROP_VALIDATORS[propType.type], type: propType.type };\n        }\n        // If no type and value this object is likely the value\n        if (propType.value === undefined) {\n            return { type: 'object', value: propType };\n        }\n        type = getTypeOf(propType.value);\n        return { ...propType, ...DEFAULT_PROP_VALIDATORS[type], type };\n    }\n    throw new Error('props');\n}\n/**\n * \"improved\" version of javascript typeof that can distinguish arrays and null values\n */\nfunction getTypeOf(value) {\n    if (Array.isArray(value) || ArrayBuffer.isView(value)) {\n        return 'array';\n    }\n    return typeof value;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const MODULE_INJECTORS_VS = /* glsl */ `\\\n#ifdef MODULE_LOGDEPTH\n  logdepth_adjustPosition(gl_Position);\n#endif\n`;\nexport const MODULE_INJECTORS_FS = /* glsl */ `\\\n#ifdef MODULE_MATERIAL\n  gl_FragColor = material_filterColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_LIGHTING\n  gl_FragColor = lighting_filterColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_FOG\n  gl_FragColor = fog_filterColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_PICKING\n  gl_FragColor = picking_filterHighlightColor(gl_FragColor);\n  gl_FragColor = picking_filterPickingColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_LOGDEPTH\n  logdepth_setFragDepth();\n#endif\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { MODULE_INJECTORS_VS, MODULE_INJECTORS_FS } from \"../../module-injectors.js\";\nimport { assert } from \"../utils/assert.js\";\n// TODO - experimental\nconst MODULE_INJECTORS = {\n    vertex: MODULE_INJECTORS_VS,\n    fragment: MODULE_INJECTORS_FS\n};\nconst REGEX_START_OF_MAIN = /void\\s+main\\s*\\([^)]*\\)\\s*\\{\\n?/; // Beginning of main\nconst REGEX_END_OF_MAIN = /}\\n?[^{}]*$/; // End of main, assumes main is last function\nconst fragments = [];\nexport const DECLARATION_INJECT_MARKER = '__LUMA_INJECT_DECLARATIONS__';\n/**\n *\n */\nexport function normalizeInjections(injections) {\n    const result = { vertex: {}, fragment: {} };\n    for (const hook in injections) {\n        let injection = injections[hook];\n        const stage = getHookStage(hook);\n        if (typeof injection === 'string') {\n            injection = {\n                order: 0,\n                injection\n            };\n        }\n        result[stage][hook] = injection;\n    }\n    return result;\n}\nfunction getHookStage(hook) {\n    const type = hook.slice(0, 2);\n    switch (type) {\n        case 'vs':\n            return 'vertex';\n        case 'fs':\n            return 'fragment';\n        default:\n            throw new Error(type);\n    }\n}\n/**\n// A minimal shader injection/templating system.\n// RFC: https://github.com/visgl/luma.gl/blob/7.0-release/dev-docs/RFCs/v6.0/shader-injection-rfc.md\n * @param source\n * @param type\n * @param inject\n * @param injectStandardStubs\n * @returns\n */\n// eslint-disable-next-line complexity\nexport function injectShader(source, stage, inject, injectStandardStubs = false) {\n    const isVertex = stage === 'vertex';\n    for (const key in inject) {\n        const fragmentData = inject[key];\n        fragmentData.sort((a, b) => a.order - b.order);\n        fragments.length = fragmentData.length;\n        for (let i = 0, len = fragmentData.length; i < len; ++i) {\n            fragments[i] = fragmentData[i].injection;\n        }\n        const fragmentString = `${fragments.join('\\n')}\\n`;\n        switch (key) {\n            // declarations are injected before the main function\n            case 'vs:#decl':\n                if (isVertex) {\n                    source = source.replace(DECLARATION_INJECT_MARKER, fragmentString);\n                }\n                break;\n            // inject code at the beginning of the main function\n            case 'vs:#main-start':\n                if (isVertex) {\n                    source = source.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);\n                }\n                break;\n            // inject code at the end of main function\n            case 'vs:#main-end':\n                if (isVertex) {\n                    source = source.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);\n                }\n                break;\n            // declarations are injected before the main function\n            case 'fs:#decl':\n                if (!isVertex) {\n                    source = source.replace(DECLARATION_INJECT_MARKER, fragmentString);\n                }\n                break;\n            // inject code at the beginning of the main function\n            case 'fs:#main-start':\n                if (!isVertex) {\n                    source = source.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);\n                }\n                break;\n            // inject code at the end of main function\n            case 'fs:#main-end':\n                if (!isVertex) {\n                    source = source.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);\n                }\n                break;\n            default:\n                // TODO(Tarek): I think this usage should be deprecated.\n                // inject code after key, leaving key in place\n                source = source.replace(key, (match) => match + fragmentString);\n        }\n    }\n    // Remove if it hasn't already been replaced\n    source = source.replace(DECLARATION_INJECT_MARKER, '');\n    // Finally, if requested, insert an automatic module injector chunk\n    if (injectStandardStubs) {\n        source = source.replace(/\\}\\s*$/, (match) => match + MODULE_INJECTORS[stage]);\n    }\n    return source;\n}\n// Takes an array of inject objects and combines them into one\nexport function combineInjects(injects) {\n    const result = {};\n    assert(Array.isArray(injects) && injects.length > 1);\n    injects.forEach(inject => {\n        for (const key in inject) {\n            result[key] = result[key] ? `${result[key]}\\n${inject[key]}` : inject[key];\n        }\n    });\n    return result;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { makePropValidators, getValidatedProperties } from \"../filters/prop-types.js\";\nimport { normalizeInjections } from \"../shader-assembly/shader-injections.js\";\n// SHNDER MODULE API\nexport function initializeShaderModules(modules) {\n    modules.map((module) => initializeShaderModule(module));\n}\nexport function initializeShaderModule(module) {\n    if (module.instance) {\n        return;\n    }\n    initializeShaderModules(module.dependencies || []);\n    const { uniformPropTypes = {}, deprecations = [], \n    // defines = {},\n    inject = {} } = module;\n    const instance = {\n        normalizedInjections: normalizeInjections(inject),\n        parsedDeprecations: parseDeprecationDefinitions(deprecations)\n    };\n    if (uniformPropTypes) {\n        instance.propValidators = makePropValidators(uniformPropTypes);\n    }\n    module.instance = instance;\n}\n/** Convert module props to uniforms */\nexport function getShaderModuleUniforms(module, props, oldUniforms) {\n    initializeShaderModule(module);\n    const uniforms = oldUniforms || { ...module.defaultUniforms };\n    // If module has a getUniforms function, use it\n    if (module.getUniforms) {\n        return module.getUniforms(props, uniforms);\n    }\n    // Build uniforms from the uniforms array\n    // @ts-expect-error\n    return getValidatedProperties(props, module.instance?.propValidators, module.name);\n}\n/* TODO this looks like it was unused code\n  _defaultGetUniforms(opts: Record<string, any> = {}): Record<string, any> {\n    const uniforms: Record<string, any> = {};\n    const propTypes = this.uniforms;\n\n    for (const key in propTypes) {\n      const propDef = propTypes[key];\n      if (key in opts && !propDef.private) {\n        if (propDef.validate) {\n          assert(propDef.validate(opts[key], propDef), `${this.name}: invalid ${key}`);\n        }\n        uniforms[key] = opts[key];\n      } else {\n        uniforms[key] = propDef.value;\n      }\n    }\n\n    return uniforms;\n  }\n}\n*/\n// Warn about deprecated uniforms or functions\nexport function checkShaderModuleDeprecations(shaderModule, shaderSource, log) {\n    shaderModule.deprecations?.forEach(def => {\n        if (def.regex?.test(shaderSource)) {\n            if (def.deprecated) {\n                log.deprecated(def.old, def.new)();\n            }\n            else {\n                log.removed(def.old, def.new)();\n            }\n        }\n    });\n}\n// HELPERS\nfunction parseDeprecationDefinitions(deprecations) {\n    deprecations.forEach(def => {\n        switch (def.type) {\n            case 'function':\n                def.regex = new RegExp(`\\\\b${def.old}\\\\(`);\n                break;\n            default:\n                def.regex = new RegExp(`${def.type} ${def.old};`);\n        }\n    });\n    return deprecations;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { initializeShaderModules } from \"../shader-module/shader-module.js\";\n/**\n * Takes a list of shader module names and returns a new list of\n * shader module names that includes all dependencies, sorted so\n * that modules that are dependencies of other modules come first.\n *\n * If the shader glsl code from the returned modules is concatenated\n * in the reverse order, it is guaranteed that all functions be resolved and\n * that all function and variable definitions come before use.\n *\n * @param modules - Array of modules (inline modules or module names)\n * @return - Array of modules\n */\nexport function getShaderModuleDependencies(modules) {\n    initializeShaderModules(modules);\n    const moduleMap = {};\n    const moduleDepth = {};\n    getDependencyGraph({ modules, level: 0, moduleMap, moduleDepth });\n    // Return a reverse sort so that dependencies come before the modules that use them\n    const dependencies = Object.keys(moduleDepth)\n        .sort((a, b) => moduleDepth[b] - moduleDepth[a])\n        .map(name => moduleMap[name]);\n    initializeShaderModules(dependencies);\n    return dependencies;\n}\n/**\n * Recursively checks module dependencies to calculate dependency level of each module.\n *\n * @param options.modules - Array of modules\n * @param options.level - Current level\n * @param options.moduleMap -\n * @param options.moduleDepth - Current level\n * @return - Map of module name to its level\n */\n// Adds another level of dependencies to the result map\nexport function getDependencyGraph(options) {\n    const { modules, level, moduleMap, moduleDepth } = options;\n    if (level >= 5) {\n        throw new Error('Possible loop in shader dependency graph');\n    }\n    // Update level on all current modules\n    for (const module of modules) {\n        moduleMap[module.name] = module;\n        if (moduleDepth[module.name] === undefined || moduleDepth[module.name] < level) {\n            moduleDepth[module.name] = level;\n        }\n    }\n    // Recurse\n    for (const module of modules) {\n        if (module.dependencies) {\n            getDependencyGraph({ modules: module.dependencies, level: level + 1, moduleMap, moduleDepth });\n        }\n    }\n}\n/**\n * Takes a list of shader module names and returns a new list of\n * shader module names that includes all dependencies, sorted so\n * that modules that are dependencies of other modules come first.\n *\n * If the shader glsl code from the returned modules is concatenated\n * in the reverse order, it is guaranteed that all functions be resolved and\n * that all function and variable definitions come before use.\n *\n * @param modules - Array of modules (inline modules or module names)\n * @return - Array of modules\n */\nexport function getShaderDependencies(modules) {\n    initializeShaderModules(modules);\n    const moduleMap = {};\n    const moduleDepth = {};\n    getDependencyGraph({ modules, level: 0, moduleMap, moduleDepth });\n    // Return a reverse sort so that dependencies come before the modules that use them\n    modules = Object.keys(moduleDepth)\n        .sort((a, b) => moduleDepth[b] - moduleDepth[a])\n        .map(name => moduleMap[name]);\n    initializeShaderModules(modules);\n    return modules;\n}\n// DEPRECATED\n/**\n * Instantiate shader modules and resolve any dependencies\n * @deprecated Use getShaderDpendencies\n */\nexport function resolveModules(modules) {\n    return getShaderDependencies(modules);\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/** Adds defines to help identify GPU architecture / platform */\nexport function getPlatformShaderDefines(platformInfo) {\n    switch (platformInfo?.gpu.toLowerCase()) {\n        case 'apple':\n            return /* glsl */ `\\\n#define APPLE_GPU\n// Apple optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n`;\n        case 'nvidia':\n            return /* glsl */ `\\\n#define NVIDIA_GPU\n// Nvidia optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n`;\n        case 'intel':\n            return /* glsl */ `\\\n#define INTEL_GPU\n// Intel optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n// Intel's built-in 'tan' function doesn't have acceptable precision\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n`;\n        case 'amd':\n            // AMD Does not eliminate fp64 code\n            return /* glsl */ `\\\n#define AMD_GPU\n`;\n        default:\n            // We don't know what GPU it is, could be that the GPU driver or\n            // browser is not implementing UNMASKED_RENDERER constant and not\n            // reporting a correct name\n            return /* glsl */ `\\\n#define DEFAULT_GPU\n// Prevent driver from optimizing away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n// Headless Chrome's software shader 'tan' function doesn't have acceptable precision\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// If the GPU doesn't have full 32 bits precision, will causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n`;\n    }\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// TRANSPILATION TABLES\n/**\n * Transpiles GLSL 3.00 shader source code to target GLSL version (3.00 or 1.00)\n *\n * @note We always run transpiler even if same version e.g. 3.00 => 3.00\n * @note For texture sampling transpilation, apps need to use non-standard texture* calls in GLSL 3.00 source\n * RFC: https://github.com/visgl/luma.gl/blob/7.0-release/dev-docs/RFCs/v6.0/portable-glsl-300-rfc.md\n */\nexport function transpileGLSLShader(source, stage) {\n    const sourceGLSLVersion = Number(source.match(/^#version[ \\t]+(\\d+)/m)?.[1] || 100);\n    if (sourceGLSLVersion !== 300) {\n        // TODO - we splurge on a longer error message to help deck.gl custom layer developers\n        throw new Error('luma.gl v9 only supports GLSL 3.00 shader sources');\n    }\n    switch (stage) {\n        case 'vertex':\n            source = convertShader(source, ES300_VERTEX_REPLACEMENTS);\n            return source;\n        case 'fragment':\n            source = convertShader(source, ES300_FRAGMENT_REPLACEMENTS);\n            return source;\n        default:\n            // Unknown shader stage\n            throw new Error(stage);\n    }\n}\n/** Simple regex replacements for GLSL ES 1.00 syntax that has changed in GLSL ES 3.00 */\nconst ES300_REPLACEMENTS = [\n    // Fix poorly formatted version directive\n    [/^(#version[ \\t]+(100|300[ \\t]+es))?[ \\t]*\\n/, '#version 300 es\\n'],\n    // The individual `texture...()` functions were replaced with `texture()` overloads\n    [/\\btexture(2D|2DProj|Cube)Lod(EXT)?\\(/g, 'textureLod('],\n    [/\\btexture(2D|2DProj|Cube)(EXT)?\\(/g, 'texture(']\n];\nconst ES300_VERTEX_REPLACEMENTS = [\n    ...ES300_REPLACEMENTS,\n    // `attribute` keyword replaced with `in`\n    [makeVariableTextRegExp('attribute'), 'in $1'],\n    // `varying` keyword replaced with `out`\n    [makeVariableTextRegExp('varying'), 'out $1']\n];\n/** Simple regex replacements for GLSL ES 1.00 syntax that has changed in GLSL ES 3.00 */\nconst ES300_FRAGMENT_REPLACEMENTS = [\n    ...ES300_REPLACEMENTS,\n    // `varying` keyword replaced with `in`\n    [makeVariableTextRegExp('varying'), 'in $1']\n];\nfunction convertShader(source, replacements) {\n    for (const [pattern, replacement] of replacements) {\n        source = source.replace(pattern, replacement);\n    }\n    return source;\n}\n/**\n * Creates a regexp that tests for a specific variable type\n * @example\n *   should match:\n *     in float weight;\n *     out vec4 positions[2];\n *   should not match:\n *     void f(out float a, in float b) {}\n */\nfunction makeVariableTextRegExp(qualifier) {\n    return new RegExp(`\\\\b${qualifier}[ \\\\t]+(\\\\w+[ \\\\t]+\\\\w+(\\\\[\\\\w+\\\\])?;)`, 'g');\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/** Generate hook source code */\nexport function getShaderHooks(hookFunctions, hookInjections) {\n    let result = '';\n    for (const hookName in hookFunctions) {\n        const hookFunction = hookFunctions[hookName];\n        result += `void ${hookFunction.signature} {\\n`;\n        if (hookFunction.header) {\n            result += `  ${hookFunction.header}`;\n        }\n        if (hookInjections[hookName]) {\n            const injections = hookInjections[hookName];\n            injections.sort((a, b) => a.order - b.order);\n            for (const injection of injections) {\n                result += `  ${injection.injection}\\n`;\n            }\n        }\n        if (hookFunction.footer) {\n            result += `  ${hookFunction.footer}`;\n        }\n        result += '}\\n';\n    }\n    return result;\n}\n/**\n * Parse string based hook functions\n * And split per shader\n */\nexport function normalizeShaderHooks(hookFunctions) {\n    const result = { vertex: {}, fragment: {} };\n    for (const hookFunction of hookFunctions) {\n        let opts;\n        let hook;\n        if (typeof hookFunction !== 'string') {\n            opts = hookFunction;\n            hook = opts.hook;\n        }\n        else {\n            opts = {};\n            hook = hookFunction;\n        }\n        hook = hook.trim();\n        const [shaderStage, signature] = hook.split(':');\n        const name = hook.replace(/\\(.+/, '');\n        const normalizedHook = Object.assign(opts, { signature });\n        switch (shaderStage) {\n            case 'vs':\n                result.vertex[name] = normalizedHook;\n                break;\n            case 'fs':\n                result.fragment[name] = normalizedHook;\n                break;\n            default:\n                throw new Error(shaderStage);\n        }\n    }\n    return result;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/** Extracts information from shader source code */\nexport function getShaderInfo(source, defaultName) {\n    return {\n        name: getShaderName(source, defaultName),\n        language: 'glsl',\n        version: getShaderVersion(source)\n    };\n}\n/** Extracts GLSLIFY style naming of shaders: `#define SHADER_NAME ...` */\nfunction getShaderName(shader, defaultName = 'unnamed') {\n    const SHADER_NAME_REGEXP = /#define[^\\S\\r\\n]*SHADER_NAME[^\\S\\r\\n]*([A-Za-z0-9_-]+)\\s*/;\n    const match = SHADER_NAME_REGEXP.exec(shader);\n    return match ? match[1] : defaultName;\n}\n/** returns GLSL shader version of given shader string */\nfunction getShaderVersion(source) {\n    let version = 100;\n    const words = source.match(/[^\\s]+/g);\n    if (words && words.length >= 2 && words[0] === '#version') {\n        const parsedVersion = parseInt(words[1], 10);\n        if (Number.isFinite(parsedVersion)) {\n            version = parsedVersion;\n        }\n    }\n    if (version !== 100 && version !== 300) {\n        throw new Error(`Invalid GLSL version ${version}`);\n    }\n    return version;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { getShaderModuleDependencies } from \"../shader-module/shader-module-dependencies.js\";\nimport { getPlatformShaderDefines } from \"./platform-defines.js\";\nimport { injectShader, DECLARATION_INJECT_MARKER } from \"./shader-injections.js\";\nimport { transpileGLSLShader } from \"../shader-transpiler/transpile-glsl-shader.js\";\nimport { checkShaderModuleDeprecations } from \"../shader-module/shader-module.js\";\nimport { normalizeShaderHooks, getShaderHooks } from \"./shader-hooks.js\";\nimport { assert } from \"../utils/assert.js\";\nimport { getShaderInfo } from \"../glsl-utils/get-shader-info.js\";\nconst INJECT_SHADER_DECLARATIONS = `\\n\\n${DECLARATION_INJECT_MARKER}\\n`;\n/**\n * Precision prologue to inject before functions are injected in shader\n * TODO - extract any existing prologue in the fragment source and move it up...\n */\nconst FRAGMENT_SHADER_PROLOGUE = /* glsl */ `\\\nprecision highp float;\n`;\n/**\n * Inject a list of shader modules into a single shader source for WGSL\n */\nexport function assembleWGSLShader(options) {\n    const modules = getShaderModuleDependencies(options.modules || []);\n    return {\n        source: assembleShaderWGSL(options.platformInfo, {\n            ...options,\n            source: options.source,\n            stage: 'vertex',\n            modules\n        }),\n        getUniforms: assembleGetUniforms(modules)\n    };\n}\n/**\n * Injects dependent shader module sources into pair of main vertex/fragment shader sources for GLSL\n */\nexport function assembleGLSLShaderPair(options) {\n    const { vs, fs } = options;\n    const modules = getShaderModuleDependencies(options.modules || []);\n    return {\n        vs: assembleShaderGLSL(options.platformInfo, {\n            ...options,\n            source: vs,\n            stage: 'vertex',\n            modules\n        }),\n        fs: assembleShaderGLSL(options.platformInfo, {\n            ...options,\n            // @ts-expect-error\n            source: fs,\n            stage: 'fragment',\n            modules\n        }),\n        getUniforms: assembleGetUniforms(modules)\n    };\n}\n/**\n * Pulls together complete source code for either a vertex or a fragment shader\n * adding prologues, requested module chunks, and any final injections.\n * @param gl\n * @param options\n * @returns\n */\nexport function assembleShaderWGSL(platformInfo, options) {\n    const { \n    // id,\n    source, stage, modules, \n    // defines = {},\n    hookFunctions = [], inject = {}, log } = options;\n    assert(typeof source === 'string', 'shader source must be a string');\n    // const isVertex = type === 'vs';\n    // const sourceLines = source.split('\\n');\n    const coreSource = source;\n    // Combine Module and Application Defines\n    // const allDefines = {};\n    // modules.forEach(module => {\n    //   Object.assign(allDefines, module.getDefines());\n    // });\n    // Object.assign(allDefines, defines);\n    // Add platform defines (use these to work around platform-specific bugs and limitations)\n    // Add common defines (GLSL version compatibility, feature detection)\n    // Add precision declaration for fragment shaders\n    let assembledSource = '';\n    //   prologue\n    //     ? `\\\n    // ${getShaderNameDefine({id, source, type})}\n    // ${getShaderType(type)}\n    // ${getPlatformShaderDefines(platformInfo)}\n    // ${getApplicationDefines(allDefines)}\n    // ${isVertex ? '' : FRAGMENT_SHADER_PROLOGUE}\n    // `\n    // `;\n    const hookFunctionMap = normalizeShaderHooks(hookFunctions);\n    // Add source of dependent modules in resolved order\n    const hookInjections = {};\n    const declInjections = {};\n    const mainInjections = {};\n    for (const key in inject) {\n        const injection = typeof inject[key] === 'string' ? { injection: inject[key], order: 0 } : inject[key];\n        const match = /^(v|f)s:(#)?([\\w-]+)$/.exec(key);\n        if (match) {\n            const hash = match[2];\n            const name = match[3];\n            if (hash) {\n                if (name === 'decl') {\n                    declInjections[key] = [injection];\n                }\n                else {\n                    mainInjections[key] = [injection];\n                }\n            }\n            else {\n                hookInjections[key] = [injection];\n            }\n        }\n        else {\n            // Regex injection\n            mainInjections[key] = [injection];\n        }\n    }\n    // TODO - hack until shadertool modules support WebGPU\n    const modulesToInject = platformInfo.type !== 'webgpu' ? modules : [];\n    for (const module of modulesToInject) {\n        if (log) {\n            checkShaderModuleDeprecations(module, coreSource, log);\n        }\n        const moduleSource = getShaderModuleSource(module, stage);\n        // Add the module source, and a #define that declares it presence\n        assembledSource += moduleSource;\n        const injections = module.injections[stage];\n        for (const key in injections) {\n            const match = /^(v|f)s:#([\\w-]+)$/.exec(key);\n            if (match) {\n                const name = match[2];\n                const injectionType = name === 'decl' ? declInjections : mainInjections;\n                injectionType[key] = injectionType[key] || [];\n                injectionType[key].push(injections[key]);\n            }\n            else {\n                hookInjections[key] = hookInjections[key] || [];\n                hookInjections[key].push(injections[key]);\n            }\n        }\n    }\n    // For injectShader\n    assembledSource += INJECT_SHADER_DECLARATIONS;\n    assembledSource = injectShader(assembledSource, stage, declInjections);\n    assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);\n    // Add the version directive and actual source of this shader\n    assembledSource += coreSource;\n    // Apply any requested shader injections\n    assembledSource = injectShader(assembledSource, stage, mainInjections);\n    return assembledSource;\n}\n/**\n * Pulls together complete source code for either a vertex or a fragment shader\n * adding prologues, requested module chunks, and any final injections.\n * @param gl\n * @param options\n * @returns\n */\nfunction assembleShaderGLSL(platformInfo, options) {\n    const { id, source, stage, language = 'glsl', modules, defines = {}, hookFunctions = [], inject = {}, prologue = true, log } = options;\n    assert(typeof source === 'string', 'shader source must be a string');\n    const sourceVersion = language === 'glsl' ? getShaderInfo(source).version : -1;\n    const targetVersion = platformInfo.shaderLanguageVersion;\n    const sourceVersionDirective = sourceVersion === 100 ? '#version 100' : '#version 300 es';\n    const sourceLines = source.split('\\n');\n    // TODO : keep all pre-processor statements at the beginning of the shader.\n    const coreSource = sourceLines.slice(1).join('\\n');\n    // Combine Module and Application Defines\n    const allDefines = {};\n    modules.forEach(module => {\n        Object.assign(allDefines, module.defines);\n    });\n    Object.assign(allDefines, defines);\n    // Add platform defines (use these to work around platform-specific bugs and limitations)\n    // Add common defines (GLSL version compatibility, feature detection)\n    // Add precision declaration for fragment shaders\n    let assembledSource = '';\n    switch (language) {\n        case 'wgsl':\n            break;\n        case 'glsl':\n            assembledSource = prologue\n                ? `\\\n${sourceVersionDirective}\n\n// ----- PROLOGUE -------------------------\n${getShaderNameDefine({ id, source, stage })}\n${`#define SHADER_TYPE_${stage.toUpperCase()}`}\n\n${getPlatformShaderDefines(platformInfo)}\n${stage === 'fragment' ? FRAGMENT_SHADER_PROLOGUE : ''}\n\n// ----- APPLICATION DEFINES -------------------------\n\n${getApplicationDefines(allDefines)}\n\n`\n                : `${sourceVersionDirective}\n`;\n            break;\n    }\n    const hookFunctionMap = normalizeShaderHooks(hookFunctions);\n    // Add source of dependent modules in resolved order\n    const hookInjections = {};\n    const declInjections = {};\n    const mainInjections = {};\n    for (const key in inject) {\n        const injection = typeof inject[key] === 'string' ? { injection: inject[key], order: 0 } : inject[key];\n        const match = /^(v|f)s:(#)?([\\w-]+)$/.exec(key);\n        if (match) {\n            const hash = match[2];\n            const name = match[3];\n            if (hash) {\n                if (name === 'decl') {\n                    declInjections[key] = [injection];\n                }\n                else {\n                    mainInjections[key] = [injection];\n                }\n            }\n            else {\n                hookInjections[key] = [injection];\n            }\n        }\n        else {\n            // Regex injection\n            mainInjections[key] = [injection];\n        }\n    }\n    for (const module of modules) {\n        if (log) {\n            checkShaderModuleDeprecations(module, coreSource, log);\n        }\n        const moduleSource = getShaderModuleSource(module, stage);\n        // Add the module source, and a #define that declares it presence\n        assembledSource += moduleSource;\n        const injections = module.instance?.normalizedInjections[stage] || {};\n        for (const key in injections) {\n            const match = /^(v|f)s:#([\\w-]+)$/.exec(key);\n            if (match) {\n                const name = match[2];\n                const injectionType = name === 'decl' ? declInjections : mainInjections;\n                injectionType[key] = injectionType[key] || [];\n                injectionType[key].push(injections[key]);\n            }\n            else {\n                hookInjections[key] = hookInjections[key] || [];\n                hookInjections[key].push(injections[key]);\n            }\n        }\n    }\n    assembledSource += '// ----- MAIN SHADER SOURCE -------------------------';\n    // For injectShader\n    assembledSource += INJECT_SHADER_DECLARATIONS;\n    assembledSource = injectShader(assembledSource, stage, declInjections);\n    assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);\n    // Add the version directive and actual source of this shader\n    assembledSource += coreSource;\n    // Apply any requested shader injections\n    assembledSource = injectShader(assembledSource, stage, mainInjections);\n    if (language === 'glsl' && sourceVersion !== targetVersion) {\n        assembledSource = transpileGLSLShader(assembledSource, stage);\n    }\n    return assembledSource.trim();\n}\n/**\n * Returns a combined `getUniforms` covering the options for all the modules,\n * the created function will pass on options to the inidividual `getUniforms`\n * function of each shader module and combine the results into one object that\n * can be passed to setUniforms.\n * @param modules\n * @returns\n */\nexport function assembleGetUniforms(modules) {\n    return function getUniforms(opts) {\n        const uniforms = {};\n        for (const module of modules) {\n            // `modules` is already sorted by dependency level. This guarantees that\n            // modules have access to the uniforms that are generated by their dependencies.\n            const moduleUniforms = module.getUniforms?.(opts, uniforms);\n            Object.assign(uniforms, moduleUniforms);\n        }\n        return uniforms;\n    };\n}\n/**\n * Generate \"glslify-compatible\" SHADER_NAME defines\n * These are understood by the GLSL error parsing function\n * If id is provided and no SHADER_NAME constant is present in source, create one\n */\nfunction getShaderNameDefine(options) {\n    const { id, source, stage } = options;\n    const injectShaderName = id && source.indexOf('SHADER_NAME') === -1;\n    return injectShaderName\n        ? `\n#define SHADER_NAME ${id}_${stage}`\n        : '';\n}\n/** Generates application defines from an object of key value pairs */\nfunction getApplicationDefines(defines = {}) {\n    let sourceText = '';\n    for (const define in defines) {\n        const value = defines[define];\n        if (value || Number.isFinite(value)) {\n            sourceText += `#define ${define.toUpperCase()} ${defines[define]}\\n`;\n        }\n    }\n    return sourceText;\n}\n/** Extracts the source code chunk for the specified shader type from the named shader module */\nexport function getShaderModuleSource(module, stage) {\n    let moduleSource;\n    switch (stage) {\n        case 'vertex':\n            moduleSource = module.vs || '';\n            break;\n        case 'fragment':\n            moduleSource = module.fs || '';\n            break;\n        case 'wgsl':\n            moduleSource = module.source || '';\n            break;\n        default:\n            assert(false);\n    }\n    if (!module.name) {\n        throw new Error('Shader module must have a name');\n    }\n    const moduleName = module.name.toUpperCase().replace(/[^0-9a-z]/gi, '_');\n    return `\\\n// ----- MODULE ${module.name} ---------------\n\n#define MODULE_${moduleName}\n${moduleSource}\\\n\n\n`;\n}\n/*\nfunction getHookFunctions(\n  hookFunctions: Record<string, HookFunction>,\n  hookInjections: Record<string, Injection[]>\n): string {\n  let result = '';\n  for (const hookName in hookFunctions) {\n    const hookFunction = hookFunctions[hookName];\n    result += `void ${hookFunction.signature} {\\n`;\n    if (hookFunction.header) {\n      result += `  ${hookFunction.header}`;\n    }\n    if (hookInjections[hookName]) {\n      const injections = hookInjections[hookName];\n      injections.sort((a: {order: number}, b: {order: number}): number => a.order - b.order);\n      for (const injection of injections) {\n        result += `  ${injection.injection}\\n`;\n      }\n    }\n    if (hookFunction.footer) {\n      result += `  ${hookFunction.footer}`;\n    }\n    result += '}\\n';\n  }\n\n  return result;\n}\n\nfunction normalizeHookFunctions(hookFunctions: (string | HookFunction)[]): {\n  vs: Record<string, HookFunction>;\n  fs: Record<string, HookFunction>;\n} {\n  const result: {vs: Record<string, any>; fs: Record<string, any>} = {\n    vs: {},\n    fs: {}\n  };\n\n  hookFunctions.forEach((hookFunction: string | HookFunction) => {\n    let opts: HookFunction;\n    let hook: string;\n    if (typeof hookFunction !== 'string') {\n      opts = hookFunction;\n      hook = opts.hook;\n    } else {\n      opts = {} as HookFunction;\n      hook = hookFunction;\n    }\n    hook = hook.trim();\n    const [stage, signature] = hook.split(':');\n    const name = hook.replace(/\\(.+/, '');\n    if (stage !== 'vs' && stage !== 'fs') {\n      throw new Error(stage);\n    }\n    result[stage][name] = Object.assign(opts, {signature});\n  });\n\n  return result;\n}\n*/\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst IFDEF_REGEXP = /^\\s*\\#\\s*ifdef\\s*([a-zA-Z_]+)\\s*$/;\nconst ENDIF_REGEXP = /^\\s*\\#\\s*endif\\s*$/;\nexport function preprocess(source, options) {\n    const lines = source.split('\\n');\n    const output = [];\n    let conditional = true;\n    let currentDefine = null;\n    for (const line of lines) {\n        const matchIf = line.match(IFDEF_REGEXP);\n        const matchEnd = line.match(ENDIF_REGEXP);\n        if (matchIf) {\n            currentDefine = matchIf[1];\n            conditional = Boolean(options?.defines?.[currentDefine]);\n        }\n        else if (matchEnd) {\n            conditional = true;\n        }\n        else if (conditional) {\n            output.push(line);\n        }\n    }\n    return output.join('\\n');\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { initializeShaderModules } from \"./shader-module/shader-module.js\";\nimport { assembleWGSLShader, assembleGLSLShaderPair } from \"./shader-assembly/assemble-shaders.js\";\nimport { preprocess } from \"./preprocessor/preprocessor.js\";\n/**\n * A stateful version of `assembleShaders` that can be used to assemble shaders.\n * Supports setting of default modules and hooks.\n */\nexport class ShaderAssembler {\n    /** Default ShaderAssembler instance */\n    static defaultShaderAssembler;\n    /** Hook functions */\n    _hookFunctions = [];\n    /** Shader modules */\n    _defaultModules = [];\n    /**\n     * A default shader assembler instance - the natural place to register default modules and hooks\n     * @returns\n     */\n    static getDefaultShaderAssembler() {\n        ShaderAssembler.defaultShaderAssembler =\n            ShaderAssembler.defaultShaderAssembler || new ShaderAssembler();\n        return ShaderAssembler.defaultShaderAssembler;\n    }\n    /**\n     * Add a default module that does not have to be provided with every call to assembleShaders()\n     */\n    addDefaultModule(module) {\n        if (!this._defaultModules.find(m => m.name === (typeof module === 'string' ? module : module.name))) {\n            this._defaultModules.push(module);\n        }\n    }\n    /**\n     * Remove a default module\n     */\n    removeDefaultModule(module) {\n        const moduleName = typeof module === 'string' ? module : module.name;\n        this._defaultModules = this._defaultModules.filter(m => m.name !== moduleName);\n    }\n    /**\n     * Register a shader hook\n     * @param hook\n     * @param opts\n     */\n    addShaderHook(hook, opts) {\n        if (opts) {\n            hook = Object.assign(opts, { hook });\n        }\n        this._hookFunctions.push(hook);\n    }\n    /**\n     * Assemble a WGSL unified shader\n     * @param platformInfo\n     * @param props\n     * @returns\n     */\n    assembleWGSLShader(props) {\n        const modules = this._getModuleList(props.modules); // Combine with default modules\n        const hookFunctions = this._hookFunctions; // TODO - combine with default hook functions\n        const { source, getUniforms } = assembleWGSLShader({\n            ...props,\n            // @ts-expect-error\n            source: props.source,\n            modules,\n            hookFunctions\n        });\n        // WGSL does not have built-in preprocessing support (just compile time constants)\n        const preprocessedSource = props.platformInfo.shaderLanguage === 'wgsl' ? preprocess(source) : source;\n        return { source: preprocessedSource, getUniforms, modules };\n    }\n    /**\n     * Assemble a pair of shaders into a single shader program\n     * @param platformInfo\n     * @param props\n     * @returns\n     */\n    assembleGLSLShaderPair(props) {\n        const modules = this._getModuleList(props.modules); // Combine with default modules\n        const hookFunctions = this._hookFunctions; // TODO - combine with default hook functions\n        const assembled = assembleGLSLShaderPair({\n            ...props,\n            // @ts-expect-error\n            vs: props.vs,\n            // @ts-expect-error\n            fs: props.fs,\n            modules,\n            hookFunctions\n        });\n        return { ...assembled, modules };\n    }\n    /**\n     * Dedupe and combine with default modules\n     */\n    _getModuleList(appModules = []) {\n        const modules = new Array(this._defaultModules.length + appModules.length);\n        const seen = {};\n        let count = 0;\n        for (let i = 0, len = this._defaultModules.length; i < len; ++i) {\n            const module = this._defaultModules[i];\n            const name = module.name;\n            modules[count++] = module;\n            seen[name] = true;\n        }\n        for (let i = 0, len = appModules.length; i < len; ++i) {\n            const module = appModules[i];\n            const name = module.name;\n            if (!seen[name]) {\n                modules[count++] = module;\n                seen[name] = true;\n            }\n        }\n        modules.length = count;\n        initializeShaderModules(modules);\n        return modules;\n    }\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst FS_GLES = /* glsl */ `\\\nout vec4 transform_output;\nvoid main() {\n  transform_output = vec4(0);\n}`;\nconst FS300 = `#version 300 es\\n${FS_GLES}`;\n// Prase given glsl line and return qualifier details or null\nexport function getQualifierDetails(line, qualifiers) {\n    qualifiers = Array.isArray(qualifiers) ? qualifiers : [qualifiers];\n    const words = line.replace(/^\\s+/, '').split(/\\s+/);\n    // TODO add support for precession qualifiers (highp, mediump and lowp)\n    const [qualifier, type, definition] = words;\n    if (!qualifiers.includes(qualifier) || !type || !definition) {\n        return null;\n    }\n    const name = definition.split(';')[0];\n    return { qualifier, type, name };\n}\n/**\n * Given the shader input and output variable names,\n * builds and return a pass through fragment shader.\n */\nexport function getPassthroughFS(options) {\n    const { input, inputChannels, output } = options || {};\n    if (!input) {\n        // Default shader\n        return FS300;\n    }\n    if (!inputChannels) {\n        throw new Error('inputChannels');\n    }\n    const inputType = channelCountToType(inputChannels);\n    const outputValue = convertToVec4(input, inputChannels);\n    return `\\\n#version 300 es\nin ${inputType} ${input};\nout vec4 ${output};\nvoid main() {\n  ${output} = ${outputValue};\n}`;\n}\n/** convert glsl type to suffix */\nexport function typeToChannelSuffix(type) {\n    // prettier-ignore\n    switch (type) {\n        case 'float': return 'x';\n        case 'vec2': return 'xy';\n        case 'vec3': return 'xyz';\n        case 'vec4': return 'xyzw';\n        default:\n            throw new Error(type);\n    }\n}\n/** convert glsl type to channel count */\nexport function typeToChannelCount(type) {\n    // prettier-ignore\n    switch (type) {\n        case 'float': return 1;\n        case 'vec2': return 2;\n        case 'vec3': return 3;\n        case 'vec4': return 4;\n        default:\n            throw new Error(type);\n    }\n}\nfunction channelCountToType(channels) {\n    // prettier-ignore\n    switch (channels) {\n        case 1: return 'float';\n        case 2: return 'vec2';\n        case 3: return 'vec3';\n        case 4: return 'vec4';\n        default:\n            throw new Error(`invalid channels: ${channels}`);\n    }\n}\n/** Returns glsl instruction for converting to vec4 */\nexport function convertToVec4(variable, channels) {\n    // prettier-ignore\n    switch (channels) {\n        case 1: return `vec4(${variable}, 0.0, 0.0, 1.0)`;\n        case 2: return `vec4(${variable}, 0.0, 1.0)`;\n        case 3: return `vec4(${variable}, 1.0)`;\n        case 4: return variable;\n        default:\n            throw new Error(`invalid channels: ${channels}`);\n    }\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/**\n * Capitalize first letter of a string\n * @param {string} str\n * @returns {string}\n */\nexport function capitalize(str) {\n    return typeof str === 'string' ? str.charAt(0).toUpperCase() + str.slice(1) : str;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { capitalize } from \"../utils/capitalize.js\";\nexport function generateGLSLForModule(module, options) {\n    return generateGLSLUniformDeclarations(module, options);\n}\nfunction generateGLSLUniformDeclarations(module, options) {\n    const glsl = [];\n    // => uniform UniformBlockName {\n    switch (options.uniforms) {\n        case 'scoped-interface-blocks':\n        case 'unscoped-interface-blocks':\n            glsl.push(`uniform ${capitalize(module.name)} {`);\n            break;\n        case 'uniforms':\n        // ignore\n    }\n    for (const [uniformName, uniformFormat] of Object.entries(module.uniformTypes || {})) {\n        const glslUniformType = getGLSLUniformType(uniformFormat);\n        switch (options.uniforms) {\n            case 'scoped-interface-blocks':\n                // => uniform UniformBlockName {\n                glsl.push(`  ${glslUniformType} ${uniformName};`);\n                break;\n            case 'unscoped-interface-blocks':\n                // => uniform UniformBlockName {\n                glsl.push(`  ${glslUniformType} ${module.name}_${uniformName};`);\n                break;\n            case 'uniforms':\n                glsl.push(`uniform ${glslUniformType} ${module.name}_${uniformName};`);\n        }\n    }\n    switch (options.uniforms) {\n        case 'scoped-interface-blocks':\n            glsl.push(`} ${module.name};`);\n            break;\n        case 'unscoped-interface-blocks':\n            glsl.push('};');\n            break;\n        case 'uniforms':\n        // ignore\n    }\n    // final new line\n    glsl.push('');\n    return glsl.join('\\n');\n}\n/** Map a luma.gl WebGPU style uniform type to GLSL */\nfunction getGLSLUniformType(uniformFormat) {\n    const UNIFORM_TYPE_TO_GLSL = {\n        f32: 'float',\n        i32: 'int',\n        u32: 'uint',\n        'vec2<f32>': 'vec2',\n        'vec3<f32>': 'vec3',\n        'vec4<f32>': 'vec4',\n        'vec2<i32>': 'ivec2',\n        'vec3<i32>': 'ivec3',\n        'vec4<i32>': 'ivec4',\n        'vec2<u32>': 'uvec2',\n        'vec3<u32>': 'uvec3',\n        'vec4<u32>': 'uvec4',\n        'mat2x2<f32>': 'mat2',\n        'mat2x3<f32>': 'mat2x3',\n        'mat2x4<f32>': 'mat2x4',\n        'mat3x2<f32>': 'mat3x2',\n        'mat3x3<f32>': 'mat3',\n        'mat3x4<f32>': 'mat3x4',\n        'mat4x2<f32>': 'mat4x2',\n        'mat4x3<f32>': 'mat4x3',\n        'mat4x4<f32>': 'mat4'\n    };\n    const glsl = UNIFORM_TYPE_TO_GLSL[uniformFormat];\n    return glsl;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { capitalize } from \"../utils/capitalize.js\";\nexport function generateWGSLForModule(module, options) {\n    return generateWGSLUniformDeclarations(module, options);\n}\nexport function generateWGSLUniformDeclarations(module, options) {\n    const wgsl = [];\n    // => uniform UniformBlockName {\n    wgsl.push(`struct ${capitalize(module.name)} {`);\n    for (const [uniformName, uniformFormat] of Object.entries(module?.uniformTypes || {})) {\n        const wgslUniformType = uniformFormat;\n        wgsl.push(`  ${uniformName} : ${wgslUniformType};`);\n    }\n    wgsl.push('};');\n    wgsl.push(`var<uniform> ${module.name} : ${capitalize(module.name)};`);\n    return wgsl.join('\\n');\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { generateGLSLForModule } from \"./glsl/generate-glsl.js\";\nimport { generateWGSLForModule } from \"./wgsl/generate-wgsl.js\";\n/** Generates shader code for a module */\nexport function generateShaderForModule(module, options) {\n    switch (options.shaderLanguage) {\n        case 'glsl':\n            return generateGLSLForModule(module, options);\n        case 'wgsl':\n            return generateWGSLForModule(module, options);\n    }\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { log } from '@luma.gl/core';\nimport { WgslReflect } from 'wgsl_reflect';\n/**\n * Parse a ShaderLayout from WGSL shader source code.\n * @param source WGSL source code (can contain both @vertex and @fragment entry points)\n * @returns\n */\nexport function getShaderLayoutFromWGSL(source) {\n    const shaderLayout = { attributes: [], bindings: [] };\n    let parsedWGSL;\n    try {\n        parsedWGSL = parseWGSL(source);\n    }\n    catch (error) {\n        log.error(error.message)();\n        return shaderLayout;\n    }\n    for (const uniform of parsedWGSL.uniforms) {\n        const members = [];\n        for (const attribute of uniform.type?.members || []) {\n            members.push({\n                name: attribute.name,\n                type: getType(attribute.type)\n            });\n        }\n        shaderLayout.bindings.push({\n            type: 'uniform',\n            name: uniform.name,\n            location: uniform.binding,\n            // @ts-expect-error\n            group: uniform.group,\n            members\n        });\n    }\n    const vertex = parsedWGSL.entry.vertex[0]; // \"main\"\n    // Vertex shader inputs\n    const attributeCount = vertex?.inputs.length || 0; // inputs to \"main\"\n    for (let i = 0; i < attributeCount; i++) {\n        const wgslAttribute = vertex.inputs[i];\n        // locationType can be \"builtin\"\n        if (wgslAttribute.locationType === 'location') {\n            const type = getType(wgslAttribute.type);\n            shaderLayout.attributes.push({\n                name: wgslAttribute.name,\n                location: Number(wgslAttribute.location),\n                type\n            });\n        }\n    }\n    return shaderLayout;\n}\n/** Get a valid shader attribute type string from a wgsl-reflect type */\nfunction getType(type) {\n    return type.format ? `${type.name}<${type.format.name}>` : type.name;\n}\nfunction parseWGSL(source) {\n    try {\n        return new WgslReflect(source);\n    }\n    catch (error) {\n        if (error instanceof Error) {\n            throw error;\n        }\n        let message = 'WGSL parse error';\n        if (typeof error === 'object' && error?.message) {\n            message += `: ${error.message} `;\n        }\n        if (typeof error === 'object' && error?.token) {\n            message += error.token.line || '';\n        }\n        throw new Error(message, { cause: error });\n    }\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// Forked from THREE.js under MIT license\n// Fast Half Float Conversions, http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf\nimport { clamp } from '@math.gl/core';\n/**  */\nlet float16Tables = null;\n/** Storage that can be viewed both as float and integer */\nconst buffer = new ArrayBuffer(4);\nconst floatView = new Float32Array(buffer);\nconst uint32View = new Uint32Array(buffer);\n/**\n * float32 to float16\n * @param val\n * @returns\n */\nexport function toHalfFloat(val) {\n    float16Tables ||= generateFloat16Tables();\n    // if ( Math.abs( val ) > 65504 ) console.warn( 'toHalfFloat(): Value out of range.' );\n    val = clamp(val, -65504, 65504);\n    floatView[0] = val;\n    const f = uint32View[0];\n    const e = (f >> 23) & 0x1ff;\n    return float16Tables.baseTable[e] + ((f & 0x007fffff) >> float16Tables.shiftTable[e]);\n}\n/**\n * float16 to float32\n * @param val\n * @returns\n */\nexport function fromHalfFloat(val) {\n    float16Tables ||= generateFloat16Tables();\n    const m = val >> 10;\n    uint32View[0] =\n        float16Tables.mantissaTable[float16Tables.offsetTable[m] + (val & 0x3ff)] +\n            float16Tables.exponentTable[m];\n    return floatView[0];\n}\nfunction generateFloat16Tables() {\n    // float32 to float16 helpers\n    const baseTable = new Uint32Array(512);\n    const shiftTable = new Uint32Array(512);\n    for (let i = 0; i < 256; ++i) {\n        const e = i - 127;\n        // very small number (0, -0)\n        if (e < -27) {\n            baseTable[i] = 0x0000;\n            baseTable[i | 0x100] = 0x8000;\n            shiftTable[i] = 24;\n            shiftTable[i | 0x100] = 24;\n            // small number (denorm)\n        }\n        else if (e < -14) {\n            baseTable[i] = 0x0400 >> (-e - 14);\n            baseTable[i | 0x100] = (0x0400 >> (-e - 14)) | 0x8000;\n            shiftTable[i] = -e - 1;\n            shiftTable[i | 0x100] = -e - 1;\n            // normal number\n        }\n        else if (e <= 15) {\n            baseTable[i] = (e + 15) << 10;\n            baseTable[i | 0x100] = ((e + 15) << 10) | 0x8000;\n            shiftTable[i] = 13;\n            shiftTable[i | 0x100] = 13;\n            // large number (Infinity, -Infinity)\n        }\n        else if (e < 128) {\n            baseTable[i] = 0x7c00;\n            baseTable[i | 0x100] = 0xfc00;\n            shiftTable[i] = 24;\n            shiftTable[i | 0x100] = 24;\n            // stay (NaN, Infinity, -Infinity)\n        }\n        else {\n            baseTable[i] = 0x7c00;\n            baseTable[i | 0x100] = 0xfc00;\n            shiftTable[i] = 13;\n            shiftTable[i | 0x100] = 13;\n        }\n    }\n    // float16 to float32 helpers\n    const mantissaTable = new Uint32Array(2048);\n    const exponentTable = new Uint32Array(64);\n    const offsetTable = new Uint32Array(64);\n    for (let i = 1; i < 1024; ++i) {\n        let m = i << 13; // zero pad mantissa bits\n        let e = 0; // zero exponent\n        // normalized\n        while ((m & 0x00800000) === 0) {\n            m <<= 1;\n            e -= 0x00800000; // decrement exponent\n        }\n        m &= ~0x00800000; // clear leading 1 bit\n        e += 0x38800000; // adjust bias\n        mantissaTable[i] = m | e;\n    }\n    for (let i = 1024; i < 2048; ++i) {\n        mantissaTable[i] = 0x38000000 + ((i - 1024) << 13);\n    }\n    for (let i = 1; i < 31; ++i) {\n        exponentTable[i] = i << 23;\n    }\n    exponentTable[31] = 0x47800000;\n    exponentTable[32] = 0x80000000;\n    for (let i = 33; i < 63; ++i) {\n        exponentTable[i] = 0x80000000 + ((i - 32) << 23);\n    }\n    exponentTable[63] = 0xc7800000;\n    for (let i = 1; i < 64; ++i) {\n        if (i !== 32) {\n            offsetTable[i] = 1024;\n        }\n    }\n    return { baseTable, shiftTable, mantissaTable, exponentTable, offsetTable };\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/**\n * Calculate WebGL 64 bit float\n * @param a  - the input float number\n * @param out - the output array. If not supplied, a new array is created.\n * @param startIndex - the index in the output array to fill from. Default 0.\n * @returns - the fp64 representation of the input number\n */\nexport function fp64ify(a, out = [], startIndex = 0) {\n    const hiPart = Math.fround(a);\n    const loPart = a - hiPart;\n    out[startIndex] = hiPart;\n    out[startIndex + 1] = loPart;\n    return out;\n}\n/**\n * Calculate the low part of a WebGL 64 bit float\n * @param a the input float number\n * @returns the lower 32 bit of the number\n */\nexport function fp64LowPart(a) {\n    return a - Math.fround(a);\n}\n/**\n * Calculate WebGL 64 bit matrix (transposed \"Float64Array\")\n * @param matrix  the input matrix\n * @returns the fp64 representation of the input matrix\n */\nexport function fp64ifyMatrix4(matrix) {\n    // Transpose the projection matrix to column major for GLSL.\n    const matrixFP64 = new Float32Array(32);\n    for (let i = 0; i < 4; ++i) {\n        for (let j = 0; j < 4; ++j) {\n            const index = i * 4 + j;\n            fp64ify(matrix[j * 4 + i], matrixFP64, index * 2);\n        }\n    }\n    return matrixFP64;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nfloat random(vec3 scale, float seed) {\n  /* use the fragment position for a different seed per-pixel */\n  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n}\n`;\n/** Quick random generator for fragment shaders */\nexport const random = {\n    name: 'random',\n    fs\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// import {ShaderModule} from '../../types';\nconst fp32shader = /* glsl */ `\\\n#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND\n\n// All these functions are for substituting tan() function from Intel GPU only\nconst float TWO_PI = 6.2831854820251465;\nconst float PI_2 = 1.5707963705062866;\nconst float PI_16 = 0.1963495463132858;\n\nconst float SIN_TABLE_0 = 0.19509032368659973;\nconst float SIN_TABLE_1 = 0.3826834261417389;\nconst float SIN_TABLE_2 = 0.5555702447891235;\nconst float SIN_TABLE_3 = 0.7071067690849304;\n\nconst float COS_TABLE_0 = 0.9807852506637573;\nconst float COS_TABLE_1 = 0.9238795042037964;\nconst float COS_TABLE_2 = 0.8314695954322815;\nconst float COS_TABLE_3 = 0.7071067690849304;\n\nconst float INVERSE_FACTORIAL_3 = 1.666666716337204e-01; // 1/3!\nconst float INVERSE_FACTORIAL_5 = 8.333333767950535e-03; // 1/5!\nconst float INVERSE_FACTORIAL_7 = 1.9841270113829523e-04; // 1/7!\nconst float INVERSE_FACTORIAL_9 = 2.75573188446287533e-06; // 1/9!\n\nfloat sin_taylor_fp32(float a) {\n  float r, s, t, x;\n\n  if (a == 0.0) {\n    return 0.0;\n  }\n\n  x = -a * a;\n  s = a;\n  r = a;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_3;\n  s = s + t;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_5;\n  s = s + t;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_7;\n  s = s + t;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_9;\n  s = s + t;\n\n  return s;\n}\n\nvoid sincos_taylor_fp32(float a, out float sin_t, out float cos_t) {\n  if (a == 0.0) {\n    sin_t = 0.0;\n    cos_t = 1.0;\n  }\n  sin_t = sin_taylor_fp32(a);\n  cos_t = sqrt(1.0 - sin_t * sin_t);\n}\n\nfloat tan_taylor_fp32(float a) {\n    float sin_a;\n    float cos_a;\n\n    if (a == 0.0) {\n        return 0.0;\n    }\n\n    // 2pi range reduction\n    float z = floor(a / TWO_PI);\n    float r = a - TWO_PI * z;\n\n    float t;\n    float q = floor(r / PI_2 + 0.5);\n    int j = int(q);\n\n    if (j < -2 || j > 2) {\n        return 1.0 / 0.0;\n    }\n\n    t = r - PI_2 * q;\n\n    q = floor(t / PI_16 + 0.5);\n    int k = int(q);\n    int abs_k = int(abs(float(k)));\n\n    if (abs_k > 4) {\n        return 1.0 / 0.0;\n    } else {\n        t = t - PI_16 * q;\n    }\n\n    float u = 0.0;\n    float v = 0.0;\n\n    float sin_t, cos_t;\n    float s, c;\n    sincos_taylor_fp32(t, sin_t, cos_t);\n\n    if (k == 0) {\n        s = sin_t;\n        c = cos_t;\n    } else {\n        if (abs(float(abs_k) - 1.0) < 0.5) {\n            u = COS_TABLE_0;\n            v = SIN_TABLE_0;\n        } else if (abs(float(abs_k) - 2.0) < 0.5) {\n            u = COS_TABLE_1;\n            v = SIN_TABLE_1;\n        } else if (abs(float(abs_k) - 3.0) < 0.5) {\n            u = COS_TABLE_2;\n            v = SIN_TABLE_2;\n        } else if (abs(float(abs_k) - 4.0) < 0.5) {\n            u = COS_TABLE_3;\n            v = SIN_TABLE_3;\n        }\n        if (k > 0) {\n            s = u * sin_t + v * cos_t;\n            c = u * cos_t - v * sin_t;\n        } else {\n            s = u * sin_t - v * cos_t;\n            c = u * cos_t + v * sin_t;\n        }\n    }\n\n    if (j == 0) {\n        sin_a = s;\n        cos_a = c;\n    } else if (j == 1) {\n        sin_a = c;\n        cos_a = -s;\n    } else if (j == -1) {\n        sin_a = -c;\n        cos_a = s;\n    } else {\n        sin_a = -s;\n        cos_a = -c;\n    }\n    return sin_a / cos_a;\n}\n#endif\n\nfloat tan_fp32(float a) {\n#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND\n  return tan_taylor_fp32(a);\n#else\n  return tan(a);\n#endif\n}\n`;\n/**\n * 32 bit math library (fixups for GPUs)\n */\nexport const fp32 = {\n    name: 'fp32',\n    vs: fp32shader\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// cyan color\nconst DEFAULT_HIGHLIGHT_COLOR = new Float32Array([0, 1, 1, 1]);\nconst vs = /* glsl */ `\\\nuniform pickingUniforms {\n  float isActive;\n  float isAttribute;\n  float isHighlightActive;\n  float useFloatColors;\n  vec3 highlightedObjectColor;\n  vec4 highlightColor;\n} picking;\n\nout vec4 picking_vRGBcolor_Avalid;\n\n// Normalize unsigned byte color to 0-1 range\nvec3 picking_normalizeColor(vec3 color) {\n  return picking.useFloatColors > 0.5 ? color : color / 255.0;\n}\n\n// Normalize unsigned byte color to 0-1 range\nvec4 picking_normalizeColor(vec4 color) {\n  return picking.useFloatColors > 0.5 ? color : color / 255.0;\n}\n\nbool picking_isColorZero(vec3 color) {\n  return dot(color, vec3(1.0)) < 0.00001;\n}\n\nbool picking_isColorValid(vec3 color) {\n  return dot(color, vec3(1.0)) > 0.00001;\n}\n\n// Check if this vertex is highlighted \nbool isVertexHighlighted(vec3 vertexColor) {\n  vec3 highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);\n  return\n    bool(picking.isHighlightActive) && picking_isColorZero(abs(vertexColor - highlightedObjectColor));\n}\n\n// Set the current picking color\nvoid picking_setPickingColor(vec3 pickingColor) {\n  pickingColor = picking_normalizeColor(pickingColor);\n\n  if (bool(picking.isActive)) {\n    // Use alpha as the validity flag. If pickingColor is [0, 0, 0] fragment is non-pickable\n    picking_vRGBcolor_Avalid.a = float(picking_isColorValid(pickingColor));\n\n    if (!bool(picking.isAttribute)) {\n      // Stores the picking color so that the fragment shader can render it during picking\n      picking_vRGBcolor_Avalid.rgb = pickingColor;\n    }\n  } else {\n    // Do the comparison with selected item color in vertex shader as it should mean fewer compares\n    picking_vRGBcolor_Avalid.a = float(isVertexHighlighted(pickingColor));\n  }\n}\n\nvoid picking_setPickingAttribute(float value) {\n  if (bool(picking.isAttribute)) {\n    picking_vRGBcolor_Avalid.r = value;\n  }\n}\n\nvoid picking_setPickingAttribute(vec2 value) {\n  if (bool(picking.isAttribute)) {\n    picking_vRGBcolor_Avalid.rg = value;\n  }\n}\n\nvoid picking_setPickingAttribute(vec3 value) {\n  if (bool(picking.isAttribute)) {\n    picking_vRGBcolor_Avalid.rgb = value;\n  }\n}\n`;\nconst fs = /* glsl */ `\\\nuniform pickingUniforms {\n  float isActive;\n  float isAttribute;\n  float isHighlightActive;\n  float useFloatColors;\n  vec3 highlightedObjectColor;\n  vec4 highlightColor;\n} picking;\n\nin vec4 picking_vRGBcolor_Avalid;\n\n/*\n * Returns highlight color if this item is selected.\n */\nvec4 picking_filterHighlightColor(vec4 color) {\n  // If we are still picking, we don't highlight\n  if (picking.isActive > 0.5) {\n    return color;\n  }\n\n  bool selected = bool(picking_vRGBcolor_Avalid.a);\n\n  if (selected) {\n    // Blend in highlight color based on its alpha value\n    float highLightAlpha = picking.highlightColor.a;\n    float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);\n    float highLightRatio = highLightAlpha / blendedAlpha;\n\n    vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);\n    return vec4(blendedRGB, blendedAlpha);\n  } else {\n    return color;\n  }\n}\n\n/*\n * Returns picking color if picking enabled else unmodified argument.\n */\nvec4 picking_filterPickingColor(vec4 color) {\n  if (bool(picking.isActive)) {\n    if (picking_vRGBcolor_Avalid.a == 0.0) {\n      discard;\n    }\n    return picking_vRGBcolor_Avalid;\n  }\n  return color;\n}\n\n/*\n * Returns picking color if picking is enabled if not\n * highlight color if this item is selected, otherwise unmodified argument.\n */\nvec4 picking_filterColor(vec4 color) {\n  vec4 highlightColor = picking_filterHighlightColor(color);\n  return picking_filterPickingColor(highlightColor);\n}\n`;\n/**\n * Provides support for color-coding-based picking and highlighting.\n * In particular, supports picking a specific instance in an instanced\n * draw call and highlighting an instance based on its picking color,\n * and correspondingly, supports picking and highlighting groups of\n * primitives with the same picking color in non-instanced draw-calls\n */\nexport const picking = {\n    props: {},\n    uniforms: {},\n    name: 'picking',\n    uniformTypes: {\n        isActive: 'f32',\n        isAttribute: 'f32',\n        isHighlightActive: 'f32',\n        useFloatColors: 'f32',\n        highlightedObjectColor: 'vec3<f32>',\n        highlightColor: 'vec4<f32>'\n    },\n    defaultUniforms: {\n        isActive: false,\n        isAttribute: false,\n        isHighlightActive: false,\n        useFloatColors: true,\n        highlightedObjectColor: new Float32Array([0, 0, 0]),\n        highlightColor: DEFAULT_HIGHLIGHT_COLOR\n    },\n    vs,\n    fs,\n    getUniforms\n};\nfunction getUniforms(opts = {}, prevUniforms) {\n    const uniforms = {};\n    if (opts.highlightedObjectColor === undefined) {\n        // Unless highlightedObjectColor explicitly null or set, do not update state\n    }\n    else if (opts.highlightedObjectColor === null) {\n        uniforms.isHighlightActive = false;\n    }\n    else {\n        uniforms.isHighlightActive = true;\n        const highlightedObjectColor = opts.highlightedObjectColor.slice(0, 3);\n        uniforms.highlightedObjectColor = highlightedObjectColor;\n    }\n    if (opts.highlightColor) {\n        const color = Array.from(opts.highlightColor, x => x / 255);\n        if (!Number.isFinite(color[3])) {\n            color[3] = 1;\n        }\n        uniforms.highlightColor = color;\n    }\n    if (opts.isActive !== undefined) {\n        uniforms.isActive = Boolean(opts.isActive);\n        uniforms.isAttribute = Boolean(opts.isAttribute);\n    }\n    if (opts.useFloatColors !== undefined) {\n        uniforms.useFloatColors = Boolean(opts.useFloatColors);\n    }\n    return uniforms;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const lightingUniforms = /* glsl */ `\\\nprecision highp int;\n\n// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))\nstruct AmbientLight {\n  vec3 color;\n};\n\nstruct PointLight {\n  vec3 color;\n  vec3 position;\n  vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential\n};\n\nstruct DirectionalLight {\n  vec3 color;\n  vec3 direction;\n};\n\nuniform lightingUniforms {\n  int enabled;\n  int pointLightCount;\n  int directionalLightCount;\n\n  vec3 ambientColor;\n\n  int lightType;\n  vec3 lightColor;\n  vec3 lightDirection;\n  vec3 lightPosition;\n  vec3 lightAttenuation;\n\n  // AmbientLight ambientLight;\n  // PointLight pointLight[MAX_LIGHTS];\n  // DirectionalLight directionalLight[MAX_LIGHTS];\n} lighting;\n\nPointLight lighting_getPointLight(int index) {\n  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);\n}\n\nDirectionalLight lighting_getDirectionalLight(int index) {\n  return DirectionalLight(lighting.lightColor, lighting.lightDirection);\n} \n\nfloat getPointLightAttenuation(PointLight pointLight, float distance) {\n  return pointLight.attenuation.x\n       + pointLight.attenuation.y * distance\n       + pointLight.attenuation.z * distance * distance;\n}\n\n// #endif\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { lightingUniforms } from \"./lighting-uniforms-glsl.js\";\n/** Max number of supported lights (in addition to ambient light */\nconst MAX_LIGHTS = 5;\n/** Whether to divide */\nconst COLOR_FACTOR = 255.0;\n/** Shader type field for lights */\nexport var LIGHT_TYPE;\n(function (LIGHT_TYPE) {\n    LIGHT_TYPE[LIGHT_TYPE[\"POINT\"] = 0] = \"POINT\";\n    LIGHT_TYPE[LIGHT_TYPE[\"DIRECTIONAL\"] = 1] = \"DIRECTIONAL\";\n})(LIGHT_TYPE || (LIGHT_TYPE = {}));\n/** UBO ready lighting module */\nexport const lighting = {\n    props: {},\n    uniforms: {},\n    name: 'lighting',\n    defines: {\n        MAX_LIGHTS\n    },\n    uniformTypes: {\n        enabled: 'i32',\n        ambientLightColor: 'vec3<f32>',\n        numberOfLights: 'i32', // , array: MAX_LIGHTS,\n        lightType: 'i32', // , array: MAX_LIGHTS,\n        lightColor: 'vec3<f32>', // , array: MAX_LIGHTS,\n        lightPosition: 'vec3<f32>', // , array: MAX_LIGHTS,\n        // TODO - could combine direction and attenuation\n        lightDirection: 'vec3<f32>', // , array: MAX_LIGHTS,\n        lightAttenuation: 'vec3<f32>' // , array: MAX_LIGHTS},\n    },\n    defaultUniforms: {\n        enabled: 1,\n        ambientLightColor: [0.1, 0.1, 0.1],\n        numberOfLights: 0,\n        lightType: LIGHT_TYPE.POINT,\n        lightColor: [1, 1, 1],\n        lightPosition: [1, 1, 2],\n        // TODO - could combine direction and attenuation\n        lightDirection: [1, 1, 1],\n        lightAttenuation: [1, 1, 1]\n    },\n    vs: lightingUniforms,\n    fs: lightingUniforms,\n    getUniforms\n};\nfunction getUniforms(props, prevUniforms = {}) {\n    // Copy props so we can modify\n    props = props ? { ...props } : props;\n    // TODO legacy\n    if (!props) {\n        return { ...lighting.defaultUniforms };\n    }\n    // Support for array of lights. Type of light is detected by type field\n    if (props.lights) {\n        props = { ...props, ...extractLightTypes(props.lights), lights: undefined };\n    }\n    // Specify lights separately\n    const { ambientLight, pointLights, directionalLights } = props || {};\n    const hasLights = ambientLight ||\n        (pointLights && pointLights.length > 0) ||\n        (directionalLights && directionalLights.length > 0);\n    // TODO - this may not be the correct decision\n    if (!hasLights) {\n        return { ...lighting.defaultUniforms, enabled: 0 };\n    }\n    const uniforms = {\n        ...lighting.defaultUniforms,\n        ...prevUniforms,\n        ...getLightSourceUniforms({ ambientLight, pointLights, directionalLights })\n    };\n    if (props.enabled !== undefined) {\n        uniforms.enabled = props.enabled ? 1 : 0;\n    }\n    return uniforms;\n}\nfunction getLightSourceUniforms({ ambientLight, pointLights = [], directionalLights = [] }) {\n    const lightSourceUniforms = {\n    // lightType: new Array(MAX_LIGHTS).fill(0),\n    // lightColor: new Array(MAX_LIGHTS).fill([0, 0, 0]),\n    // lightPosition: new Array(MAX_LIGHTS).fill([0, 0, 0]),\n    // lightDirection: new Array(MAX_LIGHTS).fill([0, 0, 0]),\n    // lightAttenuation: new Array(MAX_LIGHTS).fill([0, 0, 0])\n    };\n    lightSourceUniforms.ambientLightColor = convertColor(ambientLight);\n    let currentLight = 0;\n    for (const pointLight of pointLights) {\n        // lightSourceUniforms.lightType[currentLight] = LIGHT_TYPE.POINT;\n        // lightSourceUniforms.lightColor[currentLight] = convertColor(pointLight);\n        // lightSourceUniforms.lightPosition[currentLight] = pointLight.position;\n        // lightSourceUniforms.lightAttenuation[currentLight] = [pointLight.attenuation || 1, 0, 0];\n        lightSourceUniforms.lightType = LIGHT_TYPE.POINT;\n        lightSourceUniforms.lightColor = convertColor(pointLight);\n        lightSourceUniforms.lightPosition = pointLight.position;\n        lightSourceUniforms.lightAttenuation = [pointLight.attenuation || 1, 0, 0];\n        currentLight++;\n    }\n    for (const directionalLight of directionalLights) {\n        // lightSourceUniforms.lightType[currentLight] = LIGHT_TYPE.DIRECTIONAL;\n        // lightSourceUniforms.lightColor[currentLight] = convertColor(directionalLight);\n        // lightSourceUniforms.lightPosition[currentLight] = directionalLight.position;\n        // lightSourceUniforms.lightDirection[currentLight] = directionalLight.direction;\n        lightSourceUniforms.lightType = LIGHT_TYPE.DIRECTIONAL;\n        lightSourceUniforms.lightColor = convertColor(directionalLight);\n        lightSourceUniforms.lightPosition = directionalLight.position;\n        lightSourceUniforms.lightDirection = directionalLight.direction;\n        currentLight++;\n    }\n    lightSourceUniforms.numberOfLights = currentLight;\n    return lightSourceUniforms;\n}\nfunction extractLightTypes(lights) {\n    const lightSources = { pointLights: [], directionalLights: [] };\n    for (const light of lights || []) {\n        switch (light.type) {\n            case 'ambient':\n                // Note: Only uses last ambient light\n                // TODO - add ambient light sources on CPU?\n                lightSources.ambientLight = light;\n                break;\n            case 'directional':\n                lightSources.directionalLights?.push(light);\n                break;\n            case 'point':\n                lightSources.pointLights?.push(light);\n                break;\n            default:\n            // eslint-disable-next-line\n            // console.warn(light.type);\n        }\n    }\n    return lightSources;\n}\n/** Take color 0-255 and intensity as input and output 0.0-1.0 range */\nfunction convertColor(colorDef = {}) {\n    const { color = [0, 0, 0], intensity = 1.0 } = colorDef;\n    return color.map(component => (component * intensity) / COLOR_FACTOR);\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// TODO\nexport const VS_WGSL = /* WGSL */ `\\  \nvoid dirlight_setNormal(normal: vec3<f32>) {\n  dirlight_vNormal = normalize(normal);\n}\n`;\n// TODO\nexport const FS_WGSL = /* WGSL */ `\\\nuniform dirlightUniforms {\n  vec3 lightDirection;\n} dirlight;\n\n// Returns color attenuated by angle from light source\nfn dirlight_filterColor(color: vec4<f32>, dirlightInputs): vec4<f32> {\n  const d: float = abs(dot(dirlight_vNormal, normalize(dirlight.lightDirection)));\n  return vec4<f32>(color.rgb * d, color.a);\n}\n`;\nconst VS_GLSL = /* glsl */ `\\\nout vec3 dirlight_vNormal;\n\nvoid dirlight_setNormal(vec3 normal) {\n  dirlight_vNormal = normalize(normal);\n}\n`;\nconst FS_GLSL = /* glsl */ `\\\nuniform dirlightUniforms {\n  vec3 lightDirection;\n} dirlight;\n\nin vec3 dirlight_vNormal;\n\n// Returns color attenuated by angle from light source\nvec4 dirlight_filterColor(vec4 color) {\n  float d = abs(dot(dirlight_vNormal, normalize(dirlight.lightDirection)));\n  return vec4(color.rgb * d, color.a);\n}\n`;\n/**\n * Cheap lighting - single directional light, single dot product, one uniform\n */\nexport const dirlight = {\n    props: {},\n    uniforms: {},\n    name: 'dirlight',\n    dependencies: [],\n    vs: VS_GLSL,\n    fs: FS_GLSL,\n    // fragmentInputs: [\n    //   {\n    //     name: 'dirlight_vNormal',\n    //     type: 'vec3<f32>'\n    //   }\n    // ],\n    uniformTypes: {\n        lightDirection: 'vec3<f32>'\n    },\n    defaultUniforms: {\n        lightDirection: new Float32Array([1, 1, 2])\n    },\n    getUniforms\n};\nfunction getUniforms(opts = dirlight.defaultUniforms) {\n    const uniforms = {};\n    if (opts.lightDirection) {\n        // eslint-disable-next-line camelcase\n        uniforms.dirlight_uLightDirection = opts.lightDirection;\n    }\n    return uniforms;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const GOURAUD_VS = /* glsl */ `\\\nuniform materialUniforms {\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n`;\nexport const GOURAUD_FS = /* glsl */ `\\\nuniform materialUniforms {\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {\n  vec3 halfway_direction = normalize(light_direction + view_direction);\n  float lambertian = dot(light_direction, normal_worldspace);\n  float specular = 0.0;\n  if (lambertian > 0.0) {\n    float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);\n    specular = pow(specular_angle, material.shininess);\n  }\n  lambertian = max(lambertian, 0.0);\n  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;\n}\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = surfaceColor;\n\n  if (lighting.enabled) {\n    vec3 view_direction = normalize(cameraPosition - position_worldspace);\n    lightColor = material.ambient * surfaceColor * lighting.ambientColor;\n\n    if (lighting.lightType == 0) {\n      PointLight pointLight = lighting_getPointLight(0);\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    } else if (lighting.lightType == 1) {\n      DirectionalLight directionalLight = lighting_getDirectionalLight(0);\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n    /*\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.pointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting.pointLight[i];\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.directionalLightCount) {\n        break;\n      }\n      DirectionalLight directionalLight = lighting.directionalLight[i];\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n    */\n  }\n  return lightColor;\n}\n\nvec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = vec3(0, 0, 0);\n  vec3 surfaceColor = vec3(0, 0, 0);\n\n  if (lighting.enabled) {\n    vec3 view_direction = normalize(cameraPosition - position_worldspace);\n\n    switch (lighting.lightType) {\n      case 0:\n        PointLight pointLight = lighting_getPointLight(0);\n        vec3 light_position_worldspace = pointLight.position;\n        vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n        break;\n\n      case 1:\n        DirectionalLight directionalLight = lighting_getDirectionalLight(0);\n        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n        break;\n    }\n  }\n  return lightColor;\n}\n`;\n// TODO - handle multiple lights\n/**\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.pointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getPointLight(i);\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.directionalLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getDirectionalLight(i);\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n  }\n    /**\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.pointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getPointLight(i);\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.directionalLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getDirectionalLight(i);\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n  }\n  */\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { lighting } from \"../lights/lighting.js\";\nimport { GOURAUD_VS, GOURAUD_FS } from \"./gouraud-shaders-glsl.js\";\n/** In Gouraud shading, color is calculated for each triangle vertex normal, and then color is interpolated colors across the triangle */\nexport const gouraudMaterial = {\n    props: {},\n    uniforms: {},\n    name: 'gouraud-lighting',\n    // Note these are switched between phong and gouraud\n    vs: GOURAUD_VS,\n    fs: GOURAUD_FS,\n    defines: {\n        LIGHTING_VERTEX: 1\n    },\n    dependencies: [lighting],\n    uniformTypes: {\n        ambient: 'f32',\n        diffuse: 'f32',\n        shininess: 'f32',\n        specularColor: 'vec3<f32>'\n    },\n    defaultUniforms: {\n        ambient: 0.35,\n        diffuse: 0.6,\n        shininess: 32,\n        specularColor: [0.15, 0.15, 0.15]\n    },\n    getUniforms(props) {\n        return { ...gouraudMaterial.defaultUniforms, ...props };\n    }\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const PHONG_VS = /* glsl */ `\\\nuniform phongMaterialUniforms {\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n`;\nexport const PHONG_FS = /* glsl */ `\\\nuniform phongMaterialUniforms {\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {\n  vec3 halfway_direction = normalize(light_direction + view_direction);\n  float lambertian = dot(light_direction, normal_worldspace);\n  float specular = 0.0;\n  if (lambertian > 0.0) {\n    float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);\n    specular = pow(specular_angle, material.shininess);\n  }\n  lambertian = max(lambertian, 0.0);\n  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;\n}\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = surfaceColor;\n\n  if (lighting.enabled == 0) {\n    return lightColor;\n  }\n\n  vec3 view_direction = normalize(cameraPosition - position_worldspace);\n  lightColor = material.ambient * surfaceColor * lighting.ambientColor;\n\n  if (lighting.lightType == 0) {\n    PointLight pointLight = lighting_getPointLight(0);\n    vec3 light_position_worldspace = pointLight.position;\n    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n  } else if (lighting.lightType == 1) {\n    DirectionalLight directionalLight = lighting_getDirectionalLight(0);\n    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n  }\n  \n  /*\n  for (int i = 0; i < MAX_LIGHTS; i++) {\n    if (i >= lighting.pointLightCount) {\n      break;\n    }\n    PointLight pointLight = lighting.pointLight[i];\n    vec3 light_position_worldspace = pointLight.position;\n    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n  }\n\n  for (int i = 0; i < MAX_LIGHTS; i++) {\n    if (i >= lighting.directionalLightCount) {\n      break;\n    }\n    DirectionalLight directionalLight = lighting.directionalLight[i];\n    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n  }\n  */\n  return lightColor;\n}\n\nvec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = vec3(0, 0, 0);\n  vec3 surfaceColor = vec3(0, 0, 0);\n\n  if (lighting.enabled == 0) {\n    vec3 view_direction = normalize(cameraPosition - position_worldspace);\n\n    switch (lighting.lightType) {\n      case 0:\n        PointLight pointLight = lighting_getPointLight(0);\n        vec3 light_position_worldspace = pointLight.position;\n        vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n        break;\n\n      case 1:\n        DirectionalLight directionalLight = lighting_getDirectionalLight(0);\n        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n        break;\n    }\n  }\n  return lightColor;\n}\n`;\n// TODO - handle multiple lights\n/**\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.pointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getPointLight(i);\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.directionalLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getDirectionalLight(i);\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n  }\n    /**\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.pointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getPointLight(i);\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.directionalLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getDirectionalLight(i);\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n  }\n  */\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { lighting } from \"../lights/lighting.js\";\nimport { PHONG_VS, PHONG_FS } from \"./phong-shaders-glsl.js\";\n/** In Phong shading, the normal vector is linearly interpolated across the surface of the polygon from the polygon's vertex normals. */\nexport const phongMaterial = {\n    props: {},\n    uniforms: {},\n    name: 'phong-lighting',\n    dependencies: [lighting],\n    // Note these are switched between phong and gouraud\n    vs: PHONG_VS,\n    fs: PHONG_FS,\n    defines: {\n        LIGHTING_FRAGMENT: 1\n    },\n    uniformTypes: {\n        ambient: 'f32',\n        diffuse: 'f32',\n        shininess: 'f32',\n        specularColor: 'vec3<f32>'\n    },\n    defaultUniforms: {\n        ambient: 0.35,\n        diffuse: 0.6,\n        shininess: 32,\n        specularColor: [0.15, 0.15, 0.15]\n    },\n    getUniforms(props) {\n        return { ...phongMaterial.defaultUniforms, ...props };\n    }\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const vs = /* glsl */ `\\\nuniform projection {\n  mat4 u_MVPMatrix;\n  mat4 u_ModelMatrix;\n  mat4 u_NormalMatrix;\n  // Projection\n  vec3 u_Camera;\n}\n\nvarying vec3 pbr_vPosition;\nvarying vec2 pbr_vUV;\n\n#ifdef HAS_NORMALS\n# ifdef HAS_TANGENTS\nvarying mat3 pbr_vTBN;\n# else\nvarying vec3 pbr_vNormal;\n# endif\n#endif\n\nvoid pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)\n{\n  vec4 pos = u_ModelMatrix * position;\n  pbr_vPosition = vec3(pos.xyz) / pos.w;\n\n#ifdef HAS_NORMALS\n#ifdef HAS_TANGENTS\n  vec3 normalW = normalize(vec3(u_NormalMatrix * vec4(normal.xyz, 0.0)));\n  vec3 tangentW = normalize(vec3(u_ModelMatrix * vec4(tangent.xyz, 0.0)));\n  vec3 bitangentW = cross(normalW, tangentW) * tangent.w;\n  pbr_vTBN = mat3(tangentW, bitangentW, normalW);\n#else // HAS_TANGENTS != 1\n  pbr_vNormal = normalize(vec3(u_ModelMatrix * vec4(normal.xyz, 0.0)));\n#endif\n#endif\n\n#ifdef HAS_UV\n  pbr_vUV = uv;\n#else\n  pbr_vUV = vec2(0.,0.);\n#endif\n}\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// Attribution:\n// MIT license, Copyright (c) 2016-2017 Mohamad Moneimne and Contributors\n// This fragment shader defines a reference implementation for Physically Based Shading of\n// a microfacet surface material defined by a glTF model.\n// TODO - better do the checks outside of shader\nexport const fs = /* glsl */ `\\\nprecision highp float;\n\nuniform Projection {\n  // Projection\n  uniform vec3 u_Camera;\n};\n\nuniform pbrMaterial {\n  // Material is unlit\n  bool unlit;\n\n  // Base color map\n  bool baseColorMapEnabled;\n  vec4 baseColorFactor;\n\n  bool normalMapEnabled;  \n  float normalScale; // #ifdef HAS_NORMALMAP\n\n  bool emissiveMapEnabled;\n  vec3 emissiveFactor; // #ifdef HAS_EMISSIVEMAP\n\n  vec2 metallicRoughnessValues;\n  bool metallicRoughnessMapEnabled;\n\n  bool occlusionMapEnabled;\n  float occlusionStrength; // #ifdef HAS_OCCLUSIONMAP\n  \n  bool alphaCutoffEnabled;\n  float alphaCutoff; // #ifdef ALPHA_CUTOFF\n  \n  // IBL\n  bool IBLenabled;\n  vec2 scaleIBLAmbient; // #ifdef USE_IBL\n  \n  // debugging flags used for shader output of intermediate PBR variables\n  // #ifdef PBR_DEBUG\n  vec4 scaleDiffBaseMR;\n  vec4 scaleFGDSpec;\n  // #endif\n} u_pbrMaterial;\n\n// Samplers\n#ifdef HAS_BASECOLORMAP\nuniform sampler2D u_BaseColorSampler;\n#endif\n#ifdef HAS_NORMALMAP\nuniform sampler2D u_NormalSampler;\n#endif\n#ifdef HAS_EMISSIVEMAP\nuniform sampler2D u_EmissiveSampler;\n#endif\n#ifdef HAS_METALROUGHNESSMAP\nuniform sampler2D u_MetallicRoughnessSampler;\n#endif\n#ifdef HAS_OCCLUSIONMAP\nuniform sampler2D u_OcclusionSampler;\n#endif\n#ifdef USE_IBL\nuniform samplerCube u_DiffuseEnvSampler;\nuniform samplerCube u_SpecularEnvSampler;\nuniform sampler2D u_brdfLUT;\n#endif\n\n// Inputs from vertex shader\n\nvarying vec3 pbr_vPosition;\nvarying vec2 pbr_vUV;\n\n#ifdef HAS_NORMALS\n#ifdef HAS_TANGENTS\nvarying mat3 pbr_vTBN;\n#else\nvarying vec3 pbr_vNormal;\n#endif\n#endif\n\n// Encapsulate the various inputs used by the various functions in the shading equation\n// We store values in this struct to simplify the integration of alternative implementations\n// of the shading terms, outlined in the Readme.MD Appendix.\nstruct PBRInfo {\n  float NdotL;                  // cos angle between normal and light direction\n  float NdotV;                  // cos angle between normal and view direction\n  float NdotH;                  // cos angle between normal and half vector\n  float LdotH;                  // cos angle between light direction and half vector\n  float VdotH;                  // cos angle between view direction and half vector\n  float perceptualRoughness;    // roughness value, as authored by the model creator (input to shader)\n  float metalness;              // metallic value at the surface\n  vec3 reflectance0;            // full reflectance color (normal incidence angle)\n  vec3 reflectance90;           // reflectance color at grazing angle\n  float alphaRoughness;         // roughness mapped to a more linear change in the roughness (proposed by [2])\n  vec3 diffuseColor;            // color contribution from diffuse lighting\n  vec3 specularColor;           // color contribution from specular lighting\n  vec3 n;                       // normal at surface point\n  vec3 v;                       // vector from surface point to camera\n};\n\nconst float M_PI = 3.141592653589793;\nconst float c_MinRoughness = 0.04;\n\nvec4 SRGBtoLINEAR(vec4 srgbIn)\n{\n#ifdef MANUAL_SRGB\n#ifdef SRGB_FAST_APPROXIMATION\n  vec3 linOut = pow(srgbIn.xyz,vec3(2.2));\n#else // SRGB_FAST_APPROXIMATION\n  vec3 bLess = step(vec3(0.04045),srgbIn.xyz);\n  vec3 linOut = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );\n#endif //SRGB_FAST_APPROXIMATION\n  return vec4(linOut,srgbIn.w);;\n#else //MANUAL_SRGB\n  return srgbIn;\n#endif //MANUAL_SRGB\n}\n\n// Find the normal for this fragment, pulling either from a predefined normal map\n// or from the interpolated mesh normal and tangent attributes.\nvec3 getNormal()\n{\n  // Retrieve the tangent space matrix\n#ifndef HAS_TANGENTS\n  vec3 pos_dx = dFdx(pbr_vPosition);\n  vec3 pos_dy = dFdy(pbr_vPosition);\n  vec3 tex_dx = dFdx(vec3(pbr_vUV, 0.0));\n  vec3 tex_dy = dFdy(vec3(pbr_vUV, 0.0));\n  vec3 t = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);\n\n#ifdef HAS_NORMALS\n  vec3 ng = normalize(pbr_vNormal);\n#else\n  vec3 ng = cross(pos_dx, pos_dy);\n#endif\n\n  t = normalize(t - ng * dot(ng, t));\n  vec3 b = normalize(cross(ng, t));\n  mat3 tbn = mat3(t, b, ng);\n#else // HAS_TANGENTS\n  mat3 tbn = pbr_vTBN;\n#endif\n\n#ifdef HAS_NORMALMAP\n  vec3 n = texture2D(u_NormalSampler, pbr_vUV).rgb;\n  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(u_pbrMaterial.normalScale, u_pbrMaterial.normalScale, 1.0)));\n#else\n  // The tbn matrix is linearly interpolated, so we need to re-normalize\n  vec3 n = normalize(tbn[2].xyz);\n#endif\n\n  return n;\n}\n\n// Calculation of the lighting contribution from an optional Image Based Light source.\n// Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].\n// See our README.md on Environment Maps [3] for additional discussion.\n#ifdef USE_IBL\nvec3 getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection)\n{\n  float mipCount = 9.0; // resolution of 512x512\n  float lod = (pbrInfo.perceptualRoughness * mipCount);\n  // retrieve a scale and bias to F0. See [1], Figure 3\n  vec3 brdf = SRGBtoLINEAR(texture2D(u_brdfLUT,\n    vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness))).rgb;\n  vec3 diffuseLight = SRGBtoLINEAR(textureCube(u_DiffuseEnvSampler, n)).rgb;\n\n#ifdef USE_TEX_LOD\n  vec3 specularLight = SRGBtoLINEAR(textureCubeLod(u_SpecularEnvSampler, reflection, lod)).rgb;\n#else\n  vec3 specularLight = SRGBtoLINEAR(textureCube(u_SpecularEnvSampler, reflection)).rgb;\n#endif\n\n  vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;\n  vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);\n\n  // For presentation, this allows us to disable IBL terms\n  diffuse *= u_pbrMaterial.scaleIBLAmbient.x;\n  specular *= u_pbrMaterial.scaleIBLAmbient.y;\n\n  return diffuse + specular;\n}\n#endif\n\n// Basic Lambertian diffuse\n// Implementation from Lambert's Photometria https://archive.org/details/lambertsphotome00lambgoog\n// See also [1], Equation 1\nvec3 diffuse(PBRInfo pbrInfo)\n{\n  return pbrInfo.diffuseColor / M_PI;\n}\n\n// The following equation models the Fresnel reflectance term of the spec equation (aka F())\n// Implementation of fresnel from [4], Equation 15\nvec3 specularReflection(PBRInfo pbrInfo)\n{\n  return pbrInfo.reflectance0 +\n    (pbrInfo.reflectance90 - pbrInfo.reflectance0) *\n    pow(clamp(1.0 - pbrInfo.VdotH, 0.0, 1.0), 5.0);\n}\n\n// This calculates the specular geometric attenuation (aka G()),\n// where rougher material will reflect less light back to the viewer.\n// This implementation is based on [1] Equation 4, and we adopt their modifications to\n// alphaRoughness as input as originally proposed in [2].\nfloat geometricOcclusion(PBRInfo pbrInfo)\n{\n  float NdotL = pbrInfo.NdotL;\n  float NdotV = pbrInfo.NdotV;\n  float r = pbrInfo.alphaRoughness;\n\n  float attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));\n  float attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));\n  return attenuationL * attenuationV;\n}\n\n// The following equation(s) model the distribution of microfacet normals across\n// the area being drawn (aka D())\n// Implementation from \"Average Irregularity Representation of a Roughened Surface\n// for Ray Reflection\" by T. S. Trowbridge, and K. P. Reitz\n// Follows the distribution function recommended in the SIGGRAPH 2013 course notes\n// from EPIC Games [1], Equation 3.\nfloat microfacetDistribution(PBRInfo pbrInfo)\n{\n  float roughnessSq = pbrInfo.alphaRoughness * pbrInfo.alphaRoughness;\n  float f = (pbrInfo.NdotH * roughnessSq - pbrInfo.NdotH) * pbrInfo.NdotH + 1.0;\n  return roughnessSq / (M_PI * f * f);\n}\n\nvoid PBRInfo_setAmbientLight(inout PBRInfo pbrInfo) {\n  pbrInfo.NdotL = 1.0;\n  pbrInfo.NdotH = 0.0;\n  pbrInfo.LdotH = 0.0;\n  pbrInfo.VdotH = 1.0;\n}\n\nvoid PBRInfo_setDirectionalLight(inout PBRInfo pbrInfo, vec3 lightDirection) {\n  vec3 n = pbrInfo.n;\n  vec3 v = pbrInfo.v;\n  vec3 l = normalize(lightDirection);             // Vector from surface point to light\n  vec3 h = normalize(l+v);                        // Half vector between both l and v\n\n  pbrInfo.NdotL = clamp(dot(n, l), 0.001, 1.0);\n  pbrInfo.NdotH = clamp(dot(n, h), 0.0, 1.0);\n  pbrInfo.LdotH = clamp(dot(l, h), 0.0, 1.0);\n  pbrInfo.VdotH = clamp(dot(v, h), 0.0, 1.0);\n}\n\nvoid PBRInfo_setPointLight(inout PBRInfo pbrInfo, PointLight pointLight) {\n  vec3 light_direction = normalize(pointLight.position - pbr_vPosition);\n  PBRInfo_setDirectionalLight(pbrInfo, light_direction);\n}\n\nvec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor) {\n  // Calculate the shading terms for the microfacet specular shading model\n  vec3 F = specularReflection(pbrInfo);\n  float G = geometricOcclusion(pbrInfo);\n  float D = microfacetDistribution(pbrInfo);\n\n  // Calculation of analytical lighting contribution\n  vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInfo);\n  vec3 specContrib = F * G * D / (4.0 * pbrInfo.NdotL * pbrInfo.NdotV);\n  // Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)\n  return pbrInfo.NdotL * lightColor * (diffuseContrib + specContrib);\n}\n\nvec4 pbr_filterColor(vec4 colorUnused)\n{\n  // The albedo may be defined from a base texture or a flat color\n#ifdef HAS_BASECOLORMAP\n  vec4 baseColor = SRGBtoLINEAR(texture2D(u_BaseColorSampler, pbr_vUV)) * u_pbrMaterial.baseColorFactor;\n#else\n  vec4 baseColor = u_pbrMaterial.baseColorFactor;\n#endif\n\n#ifdef ALPHA_CUTOFF\n  if (baseColor.a < u_pbrMaterial.alphaCutoff) {\n    discard;\n  }\n#endif\n\n  vec3 color = vec3(0, 0, 0);\n\n  if(u_pbrMaterial.unlit){\n    color.rgb = baseColor.rgb;\n  }\n  else{\n    // Metallic and Roughness material properties are packed together\n    // In glTF, these factors can be specified by fixed scalar values\n    // or from a metallic-roughness map\n    float perceptualRoughness = u_pbrMaterial.metallicRoughnessValues.y;\n    float metallic = u_pbrMaterial.metallicRoughnessValues.x;\n#ifdef HAS_METALROUGHNESSMAP\n    // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.\n    // This layout intentionally reserves the 'r' channel for (optional) occlusion map data\n    vec4 mrSample = texture2D(u_MetallicRoughnessSampler, pbr_vUV);\n    perceptualRoughness = mrSample.g * perceptualRoughness;\n    metallic = mrSample.b * metallic;\n#endif\n    perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);\n    metallic = clamp(metallic, 0.0, 1.0);\n    // Roughness is authored as perceptual roughness; as is convention,\n    // convert to material roughness by squaring the perceptual roughness [2].\n    float alphaRoughness = perceptualRoughness * perceptualRoughness;\n\n    vec3 f0 = vec3(0.04);\n    vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);\n    diffuseColor *= 1.0 - metallic;\n    vec3 specularColor = mix(f0, baseColor.rgb, metallic);\n\n    // Compute reflectance.\n    float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);\n\n    // For typical incident reflectance range (between 4% to 100%) set the grazing\n    // reflectance to 100% for typical fresnel effect.\n    // For very low reflectance range on highly diffuse objects (below 4%),\n    // incrementally reduce grazing reflecance to 0%.\n    float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);\n    vec3 specularEnvironmentR0 = specularColor.rgb;\n    vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;\n\n    vec3 n = getNormal();                          // normal at surface point\n    vec3 v = normalize(u_Camera - pbr_vPosition);  // Vector from surface point to camera\n\n    float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);\n    vec3 reflection = -normalize(reflect(v, n));\n\n    PBRInfo pbrInfo = PBRInfo(\n      0.0, // NdotL\n      NdotV,\n      0.0, // NdotH\n      0.0, // LdotH\n      0.0, // VdotH\n      perceptualRoughness,\n      metallic,\n      specularEnvironmentR0,\n      specularEnvironmentR90,\n      alphaRoughness,\n      diffuseColor,\n      specularColor,\n      n,\n      v\n    );\n\n#ifdef USE_LIGHTS\n    // Apply ambient light\n    PBRInfo_setAmbientLight(pbrInfo);\n    color += calculateFinalColor(pbrInfo, lighting_uAmbientLight.color);\n\n    // Apply directional light\n    for(int i = 0; i < lighting_uDirectionalLightCount; i++) {\n      if (i < lighting_uDirectionalLightCount) {\n        PBRInfo_setDirectionalLight(pbrInfo, lighting_uDirectionalLight[i].direction);\n        color += calculateFinalColor(pbrInfo, lighting_uDirectionalLight[i].color);\n      }\n    }\n\n    // Apply point light\n    for(int i = 0; i < lighting_uPointLightCount; i++) {\n      if (i < lighting_uPointLightCount) {\n        PBRInfo_setPointLight(pbrInfo, lighting_uPointLight[i]);\n        float attenuation = getPointLightAttenuation(lighting_uPointLight[i], distance(lighting_uPointLight[i].position, pbr_vPosition));\n        color += calculateFinalColor(pbrInfo, lighting_uPointLight[i].color / attenuation);\n      }\n    }\n#endif\n\n    // Calculate lighting contribution from image based lighting source (IBL)\n#ifdef USE_IBL\n    if (u_pbrMateral.IBLEnabled) {\n      color += getIBLContribution(pbrInfo, n, reflection);\n    }\n#endif\n\n    // Apply optional PBR terms for additional (optional) shading\n#ifdef HAS_OCCLUSIONMAP\n    if (u_pbrMaterial.occlusionMapEnabled) {\n      float ao = texture2D(u_OcclusionSampler, pbr_vUV).r;\n      color = mix(color, color * ao, u_pbrMaterial.occlusionStrength);\n    }\n#endif\n\n#ifdef HAS_EMISSIVEMAP\n    if (u_pbrMaterial.emmissiveMapEnabled) {\n      vec3 emissive = SRGBtoLINEAR(texture2D(u_EmissiveSampler, pbr_vUV)).rgb * u_pbrMaterial.emissiveFactor;\n      color += emissive;\n    }\n#endif\n\n    // This section uses mix to override final color for reference app visualization\n    // of various parameters in the lighting equation.\n#ifdef PBR_DEBUG\n    // TODO: Figure out how to debug multiple lights\n\n    // color = mix(color, F, u_ScaleFGDSpec.x);\n    // color = mix(color, vec3(G), u_ScaleFGDSpec.y);\n    // color = mix(color, vec3(D), u_ScaleFGDSpec.z);\n    // color = mix(color, specContrib, u_ScaleFGDSpec.w);\n\n    // color = mix(color, diffuseContrib, u_ScaleDiffBaseMR.x);\n    color = mix(color, baseColor.rgb, u_pbrMaterial.scaleDiffBaseMR.y);\n    color = mix(color, vec3(metallic), u_pbrMaterial.scaleDiffBaseMR.z);\n    color = mix(color, vec3(perceptualRoughness), u_pbrMaterial.scaleDiffBaseMR.w);\n#endif\n\n  }\n\n  return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);\n}\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { lighting } from \"../lights/lighting.js\";\nimport { vs } from \"./pbr-vertex-glsl.js\";\nimport { fs } from \"./pbr-fragment-glsl.js\";\n/**\n * An implementation of PBR (Physically-Based Rendering).\n * Physically Based Shading of a microfacet surface defined by a glTF material.\n */\nexport const pbrMaterial = {\n    props: {},\n    uniforms: {},\n    name: 'pbr',\n    dependencies: [lighting],\n    vs,\n    fs,\n    defines: {\n        LIGHTING_FRAGMENT: 1,\n        HAS_NORMALMAP: 0,\n        HAS_EMISSIVEMAP: 0,\n        HAS_OCCLUSIONMAP: 0,\n        HAS_BASECOLORMAP: 0,\n        HAS_METALROUGHNESSMAP: 0,\n        ALPHA_CUTOFF: 0,\n        USE_IBL: 0,\n        PBR_DEBUG: 0\n    },\n    uniformTypes: {\n        // Material is unlit\n        unlit: 'i32',\n        // Base color map\n        baseColorMapEnabled: 'i32',\n        baseColorFactor: 'vec4<f32>',\n        normalMapEnabled: 'i32',\n        normalScale: 'f32', // #ifdef HAS_NORMALMAP\n        emissiveMapEnabled: 'i32',\n        emissiveFactor: 'vec3<f32>', // #ifdef HAS_EMISSIVEMAP\n        metallicRoughnessValues: 'vec2<f32>',\n        metallicRoughnessMapEnabled: 'i32',\n        occlusionMapEnabled: 'i32',\n        occlusionStrength: 'f32', // #ifdef HAS_OCCLUSIONMAP\n        alphaCutoffEnabled: 'i32',\n        alphaCutoff: 'f32', // #ifdef ALPHA_CUTOFF\n        // IBL\n        IBLenabled: 'i32',\n        scaleIBLAmbient: 'vec2<f32>', // #ifdef USE_IBL\n        // debugging flags used for shader output of intermediate PBR variables\n        // #ifdef PBR_DEBUG\n        scaleDiffBaseMR: 'vec4<f32>',\n        scaleFGDSpec: 'vec4<f32>'\n    },\n    bindings: {\n        baseColorSampler: { type: 'texture', location: 8 }, // #ifdef HAS_BASECOLORMAP\n        normalSampler: { type: 'texture', location: 9 }, // #ifdef HAS_NORMALMAP\n        emissiveSampler: { type: 'texture', location: 10 }, // #ifdef HAS_EMISSIVEMAP\n        metallicRoughnessSampler: { type: 'texture', location: 11 }, // #ifdef HAS_METALROUGHNESSMAP\n        occlusionSampler: { type: 'texture', location: 12 }, // #ifdef HAS_OCCLUSIONMAP\n        // IBL Samplers\n        diffuseEnvSampler: { type: 'texture', location: 13 }, // #ifdef USE_IBL (samplerCube)\n        specularEnvSampler: { type: 'texture', location: 14 }, // #ifdef USE_IBL (samplerCube)\n        brdfLUT: { type: 'texture', location: 15 } // #ifdef USE_IBL\n    }\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\n\nuniform brightnessContrastUniforms {\n  float brightness;\n  float contrast;\n} brightnessContrast;\n\nvec4 brightnessContrast_filterColor(vec4 color) {\n  color.rgb += brightnessContrast.brightness;\n  if (brightnessContrast.contrast > 0.0) {\n    color.rgb = (color.rgb - 0.5) / (1.0 - brightnessContrast.contrast) + 0.5;\n  } else {\n    color.rgb = (color.rgb - 0.5) * (1.0 + brightnessContrast.contrast) + 0.5;\n  }\n  return color;\n}\n\nvec4 brightnessContrast_filterColor(vec4 color, vec2 texSize, vec2 texCoords) {\n  return brightnessContrast_filterColor(color);\n}\n`;\n/**\n * Brightness / Contrast -\n * Provides additive brightness and multiplicative contrast control.\n * @param brightness -1 to 1 (-1 is solid black, 0 is no change, and 1 is solid white)\n * @param contrast   -1 to 1 (-1 is solid gray, 0 is no change, and 1 is maximum contrast)\n */\nexport const brightnessContrast = {\n    props: {},\n    uniforms: {},\n    name: 'brightnessContrast',\n    uniformTypes: {\n        brightness: 'f32',\n        contrast: 'f32'\n    },\n    uniformPropTypes: {\n        brightness: { format: 'f32', value: 0, min: -1, max: 1 },\n        contrast: { format: 'f32', value: 0, min: -1, max: 1 }\n    },\n    fs,\n    passes: [{ filter: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// Do a 9x9 bilateral box filter\nconst fs = /* glsl */ `\\\nuniform denoiseUniforms {\n  float strength;\n} noise;\n\nvec4 denoise_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  float adjustedExponent = 3. + 200. * pow(1. - noise.strength, 4.);\n\n  vec4 center = texture(source, texCoord);\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n  for (float x = -4.0; x <= 4.0; x += 1.0) {\n    for (float y = -4.0; y <= 4.0; y += 1.0) {\n      vec4 offsetColor = texture(source, texCoord + vec2(x, y) / texSize);\n      float weight = 1.0 - abs(dot(offsetColor.rgb - center.rgb, vec3(0.25)));\n      weight = pow(weight, adjustedExponent);\n      color += offsetColor * weight;\n      total += weight;\n    }\n  }\n\n  return color / total;\n}\n`;\n/**\n * Denoise -\n * Smooths over grainy noise in dark images using an 9x9 box filter\n * weighted by color intensity, similar to a bilateral filter.\n */\nexport const denoise = {\n    props: {},\n    uniforms: {},\n    name: 'denoise',\n    uniformTypes: {\n        strength: 'f32'\n    },\n    uniformPropTypes: {\n        strength: { format: 'f32', value: 0.5, min: 0, max: 1 }\n        // strength: {..., adjust: (strength: number): number => 0.53 + 200 * Math.pow(1 - strength, 4) // TODO - JS preprocessing\n    },\n    fs,\n    passes: [{ sampler: true }, { sampler: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nuniform hueSaturationUniforms {\n  float hue;\n  float saturation;\n} hueSaturation;\n\nvec4 hueSaturation_filterColor(vec4 color) {\n  // hue adjustment, wolfram alpha: RotationTransform[angle, {1, 1, 1}][{x, y, z}]\n  float angle = hueSaturation.hue * 3.14159265;\n  float s = sin(angle), c = cos(angle);\n  vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;\n  float len = length(color.rgb);\n  color.rgb = vec3(\n    dot(color.rgb, weights.xyz),\n    dot(color.rgb, weights.zxy),\n    dot(color.rgb, weights.yzx)\n  );\n\n  // saturation adjustment\n  float average = (color.r + color.g + color.b) / 3.0;\n  if (hueSaturation.saturation > 0.0) {\n    color.rgb += (average - color.rgb) * (1.0 - 1.0 / (1.001 - hueSaturation.saturation));\n  } else {\n    color.rgb += (average - color.rgb) * (-hueSaturation.saturation);\n  }\n\n  return color;\n}\n\nvec4 hueSaturation_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return hueSaturation_filterColor(color);\n}\n`;\n/**\n * Hue / Saturation\n * Provides rotational hue and multiplicative saturation control. RGB color space\n * can be imagined as a cube where the axes are the red, green, and blue color\n * values. Hue changing works by rotating the color vector around the grayscale\n * line, which is the straight line from black (0, 0, 0) to white (1, 1, 1).\n * Saturation is implemented by scaling all color channel values either toward\n * or away from the average color channel value.\n */\nexport const hueSaturation = {\n    props: {},\n    uniforms: {},\n    name: 'hueSaturation',\n    fs,\n    uniformTypes: {\n        hue: 'f32',\n        saturation: 'f32'\n    },\n    uniformPropTypes: {\n        hue: { value: 0, min: -1, max: 1 },\n        saturation: { value: 0, min: -1, max: 1 }\n    },\n    passes: [{ filter: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nuniform noiseUniforms {\n  float amount;\n} noise;\n\nfloat rand(vec2 co) {\n  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);\n}\n\nvec4 noise_filterColor(vec4 color, vec2 texCoord) {\n  float diff = (rand(texCoord) - 0.5) * noise.amount;\n  color.r += diff;\n  color.g += diff;\n  color.b += diff;\n  return color;\n}\n\nvec4 noise_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return noise_filterColor(color, texCoord);\n}\n`;\n/**\n * Noise\n * Adds black and white noise to the image.\n */\nexport const noise = {\n    props: {},\n    uniforms: {},\n    name: 'noise',\n    uniformTypes: {\n        amount: 'f32'\n    },\n    uniformPropTypes: {\n        amount: { value: 0.5, min: 0, max: 1 }\n    },\n    fs,\n    passes: [{ filter: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nuniform sepiaUniforms {\n  float amount;\n} sepia;\n\nvec4 sepia_filterColor(vec4 color) {\n  float r = color.r;\n  float g = color.g;\n  float b = color.b;\n\n  color.r =\n    min(1.0, (r * (1.0 - (0.607 * sepia.amount))) + (g * (0.769 * sepia.amount)) + (b * (0.189 * sepia.amount)));\n  color.g = min(1.0, (r * 0.349 * sepia.amount) + (g * (1.0 - (0.314 * sepia.amount))) + (b * 0.168 * sepia.amount));\n  color.b = min(1.0, (r * 0.272 * sepia.amount) + (g * 0.534 * sepia.amount) + (b * (1.0 - (0.869 * sepia.amount))));\n\n  return color;\n}\n\nvec4 sepia_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return sepia_filterColor(color);\n}\n`;\n/**\n * @filter         Sepia\n * @description    Gives the image a reddish-brown monochrome tint that imitates an old photograph.\n * @param amount   0 to 1 (0 for no effect, 1 for full sepia coloring)\n */\nexport const sepia = {\n    props: {},\n    uniforms: {},\n    name: 'sepia',\n    uniformTypes: {\n        amount: 'f32'\n    },\n    uniformPropTypes: {\n        amount: { value: 0.5, min: 0, max: 1 }\n    },\n    fs,\n    passes: [{ filter: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nuniform vibranceUniforms {\n  float amount;\n} vibrance;\n\nvec4 vibrance_filterColor(vec4 color) {\n  float average = (color.r + color.g + color.b) / 3.0;\n  float mx = max(color.r, max(color.g, color.b));\n  float amt = (mx - average) * (-vibrance.amount * 3.0);\n  color.rgb = mix(color.rgb, vec3(mx), amt);\n  return color;\n}\n\nvec4 vibrance_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return vibrance_filterColor(color);\n}\n`;\n/** Vibrance - Modifies the saturation of desaturated colors, leaving saturated colors unmodified. */\nexport const vibrance = {\n    props: {},\n    uniforms: {},\n    name: 'vibrance',\n    uniformPropTypes: {\n        amount: { value: 0, min: -1, max: 1 }\n    },\n    fs,\n    passes: [{ filter: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nuniform vignetteUniforms {\n  float radius;\n  float amount;\n} vignette;\n\nvec4 vignette_filterColor(vec4 color, vec2 texCoord) {\n  float dist = distance(texCoord, vec2(0.5, 0.5));\n  float ratio = smoothstep(0.8, vignette.radius * 0.799, dist * (vignette.amount + vignette.radius));\n  return color.rgba * ratio + (1.0 - ratio)*vec4(0.0, 0.0, 0.0, 1.0);\n}\n\nvec4 vignette_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return vignette_filterColor(color, texCoord);\n}\n`;\n/**\n * Vignette -\n * Adds a simulated lens edge darkening effect.\n */\nexport const vignette = {\n    props: {},\n    uniforms: {},\n    name: 'vignette',\n    uniformTypes: {\n        radius: 'f32',\n        amount: 'f32'\n    },\n    uniformPropTypes: {\n        radius: { value: 0.5, min: 0, max: 1 },\n        amount: { value: 0.5, min: 0, max: 1 }\n    },\n    passes: [{ filter: true }],\n    fs\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { random } from \"../..//math/random/random.js\";\nconst fs = /* glsl */ `\\\nuniform tiltShiftUniforms {\n  float blurRadius;\n  float gradientRadius;\n  vec2 start;\n  vec2 end;\n  bool invert;\n} tiltShift;\n\nvec2 tiltShift_getDelta(vec2 texSize) {\n  vec2 vector = normalize((tiltShift.end - tiltShift.start) * texSize);\n  return tiltShift.invert ? vec2(-vector.y, vector.x) : vector;\n}\n\nvec4 tiltShift_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  vec2 normal = normalize(vec2((tiltShift.start.y - tiltShift.end.y) * texSize.y, (tiltShift.end.x - tiltShift.start.x) * texSize.x));\n  float radius = smoothstep(0.0, 1.0,\n    abs(dot(texCoord * texSize - tiltShift.start * texSize, normal)) / tiltShift.gradientRadius) * tiltShift.blurRadius;\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec4 offsetColor = texture(source, texCoord + tiltShift_getDelta(texSize) / texSize * percent * radius);\n\n    /* switch to pre-multiplied alpha to correctly blur transparent images */\n    offsetColor.rgb *= offsetColor.a;\n\n    color += offsetColor * weight;\n    total += weight;\n  }\n\n  color = color / total;\n\n  /* switch back from pre-multiplied alpha */\n  color.rgb /= color.a + 0.00001;\n\n  return color;\n}\n`;\n/**\n * Tilt Shift\n * Simulates the shallow depth of field normally encountered in close-up\n * photography, which makes the scene seem much smaller than it actually\n * is. This filter assumes the scene is relatively planar, in which case\n * the part of the scene that is completely in focus can be described by\n * a line (the intersection of the focal plane and the scene). An example\n * of a planar scene might be looking at a road from above at a downward\n * angle. The image is then blurred with a blur radius that starts at zero\n * on the line and increases further from the line.\n */\nexport const tiltShift = {\n    props: {},\n    uniforms: {},\n    name: 'tiltShift',\n    dependencies: [random],\n    uniformTypes: {\n        blurRadius: 'f32',\n        gradientRadius: 'f32',\n        start: 'vec2<f32>',\n        end: 'vec2<f32>',\n        invert: 'i32'\n    },\n    uniformPropTypes: {\n        blurRadius: { value: 15, min: 0, max: 50 },\n        gradientRadius: { value: 200, min: 0, max: 400 },\n        start: { value: [0, 0] },\n        end: { value: [1, 1] },\n        invert: { value: false, private: true }\n    },\n    passes: [\n        { sampler: true, uniforms: { invert: false } },\n        { sampler: true, uniforms: { invert: true } }\n    ],\n    fs\n};\n/*\nfunction tiltShift(startX, startY, endX, endY, blurRadius, gradientRadius) {\n  var dx = endX - startX;\n  var dy = endY - startY;\n  var d = Math.sqrt(dx * dx + dy * dy);\n  simpleShader.call(this, gl.tiltShift, {\n    blurRadius: blurRadius,\n    gradientRadius: gradientRadius,\n    start: [startX, startY],\n    end: [endX, endY],\n    delta: [dx / d, dy / d],\n    texSize: [this.width, this.height]\n  });\n  simpleShader.call(this, gl.tiltShift, {\n    blurRadius: blurRadius,\n    gradientRadius: gradientRadius,\n    start: [startX, startY],\n    end: [endX, endY],\n    delta: [-dy / d, dx / d],\n    texSize: [this.width, this.height]\n  });\n\n  return this;\n}\n*/\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { random } from \"../..//math/random/random.js\";\nconst fs = /* glsl */ `\\\nuniform triangleBlurUniforms {\n  float radius;\n  vec2 delta;\n} triangleBlur;\n\nvec4 triangleBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 adjustedDelta = triangleBlur.delta * triangleBlur.radius / texSize;\n\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec4 offsetColor = texture(source, texCoord + adjustedDelta * percent);\n\n    /* switch to pre-multiplied alpha to correctly blur transparent images */\n    offsetColor.rgb *= offsetColor.a;\n\n    color += offsetColor * weight;\n    total += weight;\n  }\n\n  color = color / total;\n\n  /* switch back from pre-multiplied alpha */\n  color.rgb /= color.a + 0.00001;\n\n  return color;\n}\n`;\n/**\n * @filter       Triangle Blur\n * @description  This is the most basic blur filter, which convolves the image with a\n *               pyramid filter. The pyramid filter is separable and is applied as two\n *               perpendicular triangle filters.\n */\nexport const triangleBlur = {\n    props: {},\n    uniforms: {},\n    name: 'triangleBlur',\n    uniformTypes: {\n        radius: 'f32',\n        delta: 'vec2<f32>'\n    },\n    uniformPropTypes: {\n        radius: { value: 20, min: 0, softMax: 100 },\n        delta: { value: [1, 0], private: true }\n    },\n    fs,\n    dependencies: [random],\n    passes: [\n        { sampler: true, uniforms: { delta: [1, 0] } },\n        { sampler: true, uniforms: { delta: [0, 1] } }\n    ]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { random } from \"../../math/random/random.js\";\nconst fs = `\nuniform zoomBlurUniforms {\n  vec2 center;\n  float strength;\n} zoomBlur;\n\nvec4 zoomBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n  vec2 toCenter = zoomBlur.center * texSize - texCoord * texSize;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = 0.0; t <= 40.0; t++) {\n    float percent = (t + offset) / 40.0;\n    float weight = 4.0 * (percent - percent * percent);\n    vec4 offsetColor = texture(source, texCoord + toCenter * percent * zoomBlur.strength / texSize);\n\n    /* switch to pre-multiplied alpha to correctly blur transparent images */\n    offsetColor.rgb *= offsetColor.a;\n\n    color += offsetColor * weight;\n    total += weight;\n  }\n\n  color = color / total;\n\n  /* switch back from pre-multiplied alpha */\n  color.rgb /= color.a + 0.00001;\n\n  return color;\n}\n`;\n/**\n * Zoom Blur\n * Blurs the image away from a certain point, which looks like radial motion blur.\n */\nexport const zoomBlur = {\n    props: {},\n    uniforms: {},\n    name: 'zoomBlur',\n    uniformTypes: {\n        center: 'vec2<f32>',\n        strength: 'f32'\n    },\n    uniformPropTypes: {\n        center: { value: [0.5, 0.5] },\n        strength: { value: 0.3, min: 0, softMax: 1 }\n    },\n    fs,\n    dependencies: [random],\n    passes: [{ sampler: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// TODO pass texCoord to angle\nconst fs = /* glsl */ `\\\nuniform colorHalftoneUniforms {\n  vec2 center;\n  float angle;\n  float size;\n} colorHalftone;\n\nfloat pattern(float angle, float scale, vec2 texSize, vec2 texCoord) {\n  float s = sin(angle), c = cos(angle);\n  vec2 tex = texCoord * texSize - colorHalftone.center * texSize;\n  vec2 point = vec2(\n\tc * tex.x - s * tex.y,\n\ts * tex.x + c * tex.y\n  ) * scale;\n  return (sin(point.x) * sin(point.y)) * 4.0;\n}\n\nvec4 colorHalftone_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  float scale = 3.1514 / colorHalftone.size;\n  vec3 cmy = 1.0 - color.rgb;\n  float k = min(cmy.x, min(cmy.y, cmy.z));\n\n  cmy = (cmy - k) / (1.0 - k);\n  cmy = clamp(\n\t  cmy * 10.0 - 3.0 + vec3(\n      pattern(colorHalftone.angle + 0.26179, scale, texSize, texCoord),\n\t    pattern(colorHalftone.angle + 1.30899, scale, texSize, texCoord),\n      pattern(colorHalftone.angle, scale, texSize, texCoord)\n    ),\n\t  0.0,\n\t  1.0\n  );\n  k = clamp(k * 10.0 - 5.0 + pattern(colorHalftone.angle + 0.78539, scale, texSize, texCoord), 0.0, 1.0);\n  return vec4(1.0 - cmy - k, color.a);\n}\n`;\n/**\n * Color Halftone -\n * Simulates a CMYK halftone rendering of the image by multiplying pixel values\n * with a four rotated 2D sine wave patterns, one each for cyan, magenta, yellow,\n * and black.\n */\nexport const colorHalftone = {\n    props: {},\n    uniforms: {},\n    name: 'colorHalftone',\n    uniformTypes: {\n        center: 'vec2<f32>',\n        angle: 'f32',\n        size: 'f32'\n    },\n    uniformPropTypes: {\n        center: { value: [0.5, 0.5] },\n        angle: { value: 1.1, softMin: 0, softMax: Math.PI / 2 },\n        size: { value: 4, min: 1, softMin: 3, softMax: 20 }\n    },\n    fs,\n    passes: [{ filter: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nuniform dotScreenUniforms {\n  vec2 center;\n  float angle;\n  float size;\n} dotScreen;\n\nfloat pattern(vec2 texSize, vec2 texCoord) {\n  float scale = 3.1415 / dotScreen.size;\n\n  float s = sin(dotScreen.angle), c = cos(dotScreen.angle);\n  vec2 tex = texCoord * texSize - dotScreen.center * texSize;\n  vec2 point = vec2(\n    c * tex.x - s * tex.y,\n    s * tex.x + c * tex.y\n  ) * scale;\n  return (sin(point.x) * sin(point.y)) * 4.0;\n}\n\nvec4 dotScreen_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  float average = (color.r + color.g + color.b) / 3.0;\n  return vec4(vec3(average * 10.0 - 5.0 + pattern(texSize, texCoord)), color.a);\n}\n`;\n/**\n * Dot Screen -\n * Simulates a black and white halftone rendering of the image by multiplying\n * pixel values with a rotated 2D sine wave pattern.\n */\nexport const dotScreen = {\n    props: {},\n    uniforms: {},\n    name: 'dotScreen',\n    uniformTypes: {\n        center: 'vec2<f32>',\n        angle: 'f32',\n        size: 'f32'\n    },\n    uniformPropTypes: {\n        center: { value: [0.5, 0.5] },\n        angle: { value: 1.1, softMin: 0, softMax: Math.PI / 2 },\n        size: { value: 3, min: 1, softMin: 3, softMax: 20 }\n    },\n    fs,\n    passes: [{ filter: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { random } from \"../../math/random/random.js\";\nconst fs = /* glsl */ `\\\nuniform edgeWorkUniforms {\n  float radius;\n  vec2 delta;\n} edgeWork;\n\nvec4 edgeWork_sampleColor1(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;\n\n  vec2 color = vec2(0.0);\n  vec2 total = vec2(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec3 sampleColor = texture(source, texCoord + relativeDelta * percent).rgb;\n    float average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;\n    color.x += average * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += average * weight;\n      total.y += weight;\n    }\n  }\n  return vec4(color / total, 0.0, 1.0);\n}\n\nvec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;\n\n  vec2 color = vec2(0.0);\n  vec2 total = vec2(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec2 sampleColor = texture(source, texCoord + relativeDelta * percent).xy;\n    color.x += sampleColor.x * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += sampleColor.y * weight;\n      total.y += weight;\n    }\n  }\n  float c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);\n  return vec4(c, c, c, 1.0);\n}\n`;\n/**\n * Edge Work -\n * Picks out different frequencies in the image by subtracting two\n * copies of the image blurred with different radii.\n */\nexport const edgeWork = {\n    props: {},\n    uniforms: {},\n    name: 'edgeWork',\n    dependencies: [random],\n    fs,\n    uniformPropTypes: {\n        radius: { value: 2, min: 1, softMax: 50 },\n        delta: { value: [1, 0], private: true }\n    },\n    passes: [\n        {\n            // @ts-expect-error\n            sampler: 'edgeWork_sampleColor1',\n            uniformPropTypes: { delta: [1, 0] }\n        },\n        {\n            // @ts-expect-error\n            sampler: 'edgeWork_sampleColor2',\n            uniformPropTypes: { delta: [0, 1] }\n        }\n    ]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nuniform hexagonalPixelateUniforms {\n  vec2 center;\n  float scale;\n} hexagonalPixelate;\n\nvec4 hexagonalPixelate_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 tex = (texCoord * texSize - hexagonalPixelate.center * texSize) / hexagonalPixelate.scale;\n  tex.y /= 0.866025404;\n  tex.x -= tex.y * 0.5;\n\n  vec2 a;\n  if (tex.x + tex.y - floor(tex.x) - floor(tex.y) < 1.0) {\n    a = vec2(floor(tex.x), floor(tex.y));\n  }\n  else a = vec2(ceil(tex.x), ceil(tex.y));\n  vec2 b = vec2(ceil(tex.x), floor(tex.y));\n  vec2 c = vec2(floor(tex.x), ceil(tex.y));\n\n  vec3 TEX = vec3(tex.x, tex.y, 1.0 - tex.x - tex.y);\n  vec3 A = vec3(a.x, a.y, 1.0 - a.x - a.y);\n  vec3 B = vec3(b.x, b.y, 1.0 - b.x - b.y);\n  vec3 C = vec3(c.x, c.y, 1.0 - c.x - c.y);\n\n  float alen = length(TEX - A);\n  float blen = length(TEX - B);\n  float clen = length(TEX - C);\n\n  vec2 choice;\n  if (alen < blen) {\n    if (alen < clen) choice = a;\n    else choice = c;\n  } else {\n    if (blen < clen) choice = b;\n    else choice = c;\n  }\n\n  choice.x += choice.y * 0.5;\n  choice.y *= 0.866025404;\n  choice *= hexagonalPixelate.scale / texSize;\n\n  return texture(source, choice + hexagonalPixelate.center);\n}\n`;\n/**\n * Hexagonal Pixelate\n * Renders the image using a pattern of hexagonal tiles. Tile colors\n * are nearest-neighbor sampled from the centers of the tiles.\n */\nexport const hexagonalPixelate = {\n    props: {},\n    uniforms: {},\n    name: 'hexagonalPixelate',\n    uniformTypes: {\n        center: 'vec2<f32>',\n        scale: 'f32'\n    },\n    uniformPropTypes: {\n        center: { value: [0.5, 0.5], hint: 'screenspace' },\n        scale: { value: 10, min: 1, softMin: 5, softMax: 50 }\n    },\n    fs,\n    passes: [{ sampler: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nuniform inkUniforms {\n  float strength;\n} ink;\n\nvec4 ink_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 dx = vec2(1.0 / texSize.x, 0.0);\n  vec2 dy = vec2(0.0, 1.0 / texSize.y);\n  vec4 color = texture(source, texCoord);\n  float bigTotal = 0.0;\n  float smallTotal = 0.0;\n  vec3 bigAverage = vec3(0.0);\n  vec3 smallAverage = vec3(0.0);\n  for (float x = -2.0; x <= 2.0; x += 1.0) {\n    for (float y = -2.0; y <= 2.0; y += 1.0) {\n      vec3 offsetColor = texture(source, texCoord + dx * x + dy * y).rgb;\n      bigAverage += offsetColor;\n      bigTotal += 1.0;\n      if (abs(x) + abs(y) < 2.0) {\n        smallAverage += offsetColor;\n        smallTotal += 1.0;\n      }\n    }\n  }\n  vec3 edge = max(vec3(0.0), bigAverage / bigTotal - smallAverage / smallTotal);\n  float power = ink.strength * ink.strength * ink.strength * ink.strength * ink.strength;\n  return vec4(color.rgb - dot(edge, edge) * power * 100000.0, color.a);\n}\n`;\n/**\n * Ink -\n * Simulates outlining the image in ink by darkening edges stronger than a\n * certain threshold. The edge detection value is the difference of two\n * copies of the image, each blurred using a blur of a different radius.\n */\nexport const ink = {\n    props: {},\n    uniforms: {},\n    name: 'ink',\n    fs,\n    uniformTypes: {\n        strength: 'f32'\n    },\n    uniformPropTypes: {\n        strength: { value: 0.25, min: 0, softMax: 1 }\n    },\n    passes: [{ sampler: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nuniform magnifyUniforms {\n  vec2 screenXY;\n  float radiusPixels;\n  float zoom;\n  float borderWidthPixels;\n  vec4 borderColor;\n} magnify;\n\nvec4 magnify_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 pos = vec2(magnify.screenXY.x, 1.0 - magnify.screenXY.y);\n  float dist = distance(texCoord * texSize, pos * texSize);\n  if (dist < magnify.radiusPixels) {\n    return texture(source, (texCoord - pos) / magnify.zoom + pos);\n  }\n\n  if (dist <= magnify.radiusPixels + magnify.borderWidthPixels) {\n    return magnify.borderColor;\n  }\n  return texture(source, texCoord);\n}\n`;\n/**\n * Magnify - display a circle with magnify effect applied to surrounding the pixels given position\n */\nexport const magnify = {\n    name: 'magnify',\n    uniformTypes: {\n        screenXY: 'vec2<f32>',\n        radiusPixels: 'f32',\n        zoom: 'f32',\n        borderWidthPixels: 'f32',\n        borderColor: 'vec4<f32>'\n    },\n    uniformPropTypes: {\n        // range 0 to 1\n        screenXY: { value: [0, 0] },\n        radiusPixels: 200,\n        zoom: 2.0,\n        borderWidthPixels: 0.0,\n        borderColor: { value: [255, 255, 255, 255] }\n    },\n    fs,\n    passes: [{ sampler: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nvec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {\n  vec4 color = texture(source, coord / texSize);\n  vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);\n  if (coord != clampedCoord) {\n    /* fade to transparent if we are outside the image */\n    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));\n  }\n\n  return color;\n}\n`;\nexport const warp = {\n    name: 'warp',\n    passes: [],\n    fs\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { warp } from \"./warp.js\";\nconst fs = /* glsl */ `\\\nuniform bulgePinchUniforms {\n  float radius;\n  float strength;\n  vec2 center;\n} bulgePinch;\n\nvec2 bulgePinch_warp(vec2 coord, vec2 texCenter) {\n  coord -= texCenter;\n  float distance = length(coord);\n  if (distance < bulgePinch.radius) {\n    float percent = distance / bulgePinch.radius;\n    if (bulgePinch.strength > 0.0) {\n      coord *= mix(1.0, smoothstep(0.0, bulgePinch.radius / distance, percent), bulgePinch.strength * 0.75);\n    } else {\n      coord *= mix(1.0, pow(percent, 1.0 + bulgePinch.strength * 0.75) * bulgePinch.radius / distance, 1.0 - percent);\n    }\n  }\n  coord += texCenter;\n  return coord;\n}\n\nvec4 bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 coord = texCoord * texSize;\n  coord = bulgePinch_warp(coord, bulgePinch.center * texSize);\n\n  return warp_sampleColor(source, texSize, coord);\n}\n`;\n/**\n * Bulge / Pinch -\n * Bulges or pinches the image in a circle.\n */\nexport const bulgePinch = {\n    props: {},\n    uniforms: {},\n    name: 'bulgePinch',\n    dependencies: [warp],\n    fs,\n    uniformTypes: {\n        center: 'vec2<f32>',\n        radius: 'f32',\n        strength: 'f32'\n    },\n    uniformPropTypes: {\n        center: { value: [0.5, 0.5] },\n        radius: { value: 200, min: 1, softMax: 600 },\n        strength: { value: 0.5, min: -1, max: 1 }\n    },\n    passes: [{ sampler: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { warp } from \"./warp.js\";\nconst fs = /* glsl */ `\\\nuniform swirlUniforms {\n  float radius;\n  float angle;\n  vec2 center;\n} swirl;\n\nvec2 swirl_warp(vec2 coord, vec2 texCenter) {\n  coord -= texCenter;\n  float distance = length(coord);\n  if (distance < swirl.radius) {\n    float percent = (swirl.radius - distance) / swirl.radius;\n    float theta = percent * percent * swirl.angle;\n    float s = sin(theta);\n    float c = cos(theta);\n    coord = vec2(\n      coord.x * c - coord.y * s,\n      coord.x * s + coord.y * c\n    );\n  }\n  coord += texCenter;\n  return coord;\n}\n\nvec4 swirl_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 coord = texCoord * texSize;\n  coord = swirl_warp(coord, swirl.center * texSize);\n\n  return warp_sampleColor(source, texSize, coord);\n}\n`;\n/**\n * Warps a circular region of the image in a swirl.\n */\nexport const swirl = {\n    props: {},\n    uniforms: {},\n    name: 'swirl',\n    dependencies: [warp],\n    fs,\n    uniformTypes: {\n        center: 'vec2<f32>',\n        radius: 'f32',\n        angle: 'f32'\n    },\n    uniformPropTypes: {\n        center: { value: [0.5, 0.5] },\n        radius: { value: 200, min: 1, softMax: 600 },\n        angle: { value: 3, softMin: -25, softMax: 25 }\n    },\n    passes: [{ sampler: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/**\n * ORIGINAL LICENCE\n * @license\n * Copyright (c) 2014-2015, NVIDIA CORPORATION. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions\n * are met:\n *  * Redistributions of source code must retain the above copyright\n *    notice, this list of conditions and the following disclaimer.\n *  * Redistributions in binary form must reproduce the above copyright\n *    notice, this list of conditions and the following disclaimer in the\n *    documentation and/or other materials provided with the distribution.\n *  * Neither the name of NVIDIA CORPORATION nor the names of its\n *    contributors may be used to endorse or promote products derived\n *    from this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY\n * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR\n * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\n * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY\n * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n// LUMA.GL\n// WebGL version from cesium.js, used under Apached 2.0 License\n// https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n// with the following modifications:\n// - fxaa_sampleColor to integrate with luma.gl\n// - Return color value with alpha to avoid another tap\n// - Calculate luminance in FxaaLuma\n// COMMENTS FROM CESIUM VERSION\n// NVIDIA GameWorks Graphics Samples GitHub link: https://github.com/NVIDIAGameWorks/GraphicsSamples\n// Original FXAA 3.11 shader link: https://github.com/NVIDIAGameWorks/GraphicsSamples/blob/master/samples/es3-kepler/FXAA/FXAA3_11.h\n//\n// Steps used to integrate into Cesium:\n// * The following defines are set:\n//       #define FXAA_PC 1\n//       #define FXAA_WEBGL_1 1\n//       #define FXAA_GREEN_AS_LUMA 1\n//       #define FXAA_EARLY_EXIT 1\n//       #define FXAA_GLSL_120 1\n// * All other preprocessor directives besides the FXAA_QUALITY__P* directives were removed.\n// * Double underscores are invalid for preprocessor directives so replace them with a single underscore. Replace\n//   /FXAA_QUALITY__P(.*)/g with /FXAA_QUALITY__P$1/.\n// * There are no implicit conversions from ivec* to vec* so replace:\n//       #define FxaaInt2 ivec2\n//           with\n//       #define FxaaInt2 vec2\n// * The texture2DLod function is only available in vertex shaders so replace:\n//       #define FxaaTexTop(t, p) texture2DLod(t, p, 0.0)\n//       #define FxaaTexOff(t, p, o, r) texture2DLod(t, p + (o * r), 0.0)\n//           with\n//       #define FxaaTexTop(t, p) texture2D(t, p)\n//       #define FxaaTexOff(t, p, o, r) texture2D(t, p + (o * r))\n// * FXAA_QUALITY_PRESET is prepended in the javascript code. We may want to expose that setting in the future.\n// * The following parameters to FxaaPixelShader_ are unused and can be removed:\n//       fxaaConsolePosPos\n//       fxaaConsoleRcpFrameOpt\n//       fxaaConsoleRcpFrameOpt2\n//       fxaaConsole360RcpFrameOpt2\n//       fxaaConsoleEdgeSharpness\n//       fxaaConsoleEdgeThreshold\n//       fxaaConsoleEdgeThresholdMi\n//       fxaaConsole360ConstDir\n//\n// Choose the quality preset.\n// This needs to be compiled into the shader as it effects code.\n// Best option to include multiple presets is to\n// in each shader define the preset, then include this file.\n//\n// OPTIONS\n// -----------------------------------------------------------------------\n// 10 to 15 - default medium dither (10=fastest, 15=highest quality)\n// 20 to 29 - less dither, more expensive (20=fastest, 29=highest quality)\n// 39       - no dither, very expensive\n//\n// NOTES\n// -----------------------------------------------------------------------\n// 12 = slightly faster then FXAA 3.9 and higher edge quality (default)\n// 13 = about same speed as FXAA 3.9 and better than 12\n// 23 = closest to FXAA 3.9 visually and performance wise\n//  _ = the lowest digit is directly related to performance\n// _  = the highest digit is directly related to style\n//\nconst fs = `\n#define FXAA_QUALITY_PRESET 29\n\n#if (FXAA_QUALITY_PRESET == 10)\n    #define FXAA_QUALITY_PS 3\n    #define FXAA_QUALITY_P0 1.5\n    #define FXAA_QUALITY_P1 3.0\n    #define FXAA_QUALITY_P2 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 11)\n    #define FXAA_QUALITY_PS 4\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 3.0\n    #define FXAA_QUALITY_P3 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 12)\n    #define FXAA_QUALITY_PS 5\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 4.0\n    #define FXAA_QUALITY_P4 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 13)\n    #define FXAA_QUALITY_PS 6\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 4.0\n    #define FXAA_QUALITY_P5 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 14)\n    #define FXAA_QUALITY_PS 7\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 4.0\n    #define FXAA_QUALITY_P6 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 15)\n    #define FXAA_QUALITY_PS 8\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 4.0\n    #define FXAA_QUALITY_P7 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 20)\n    #define FXAA_QUALITY_PS 3\n    #define FXAA_QUALITY_P0 1.5\n    #define FXAA_QUALITY_P1 2.0\n    #define FXAA_QUALITY_P2 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 21)\n    #define FXAA_QUALITY_PS 4\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 22)\n    #define FXAA_QUALITY_PS 5\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 23)\n    #define FXAA_QUALITY_PS 6\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 24)\n    #define FXAA_QUALITY_PS 7\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 3.0\n    #define FXAA_QUALITY_P6 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 25)\n    #define FXAA_QUALITY_PS 8\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 4.0\n    #define FXAA_QUALITY_P7 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 26)\n    #define FXAA_QUALITY_PS 9\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 4.0\n    #define FXAA_QUALITY_P8 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 27)\n    #define FXAA_QUALITY_PS 10\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 2.0\n    #define FXAA_QUALITY_P8 4.0\n    #define FXAA_QUALITY_P9 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 28)\n    #define FXAA_QUALITY_PS 11\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 2.0\n    #define FXAA_QUALITY_P8 2.0\n    #define FXAA_QUALITY_P9 4.0\n    #define FXAA_QUALITY_P10 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 29)\n    #define FXAA_QUALITY_PS 12\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 2.0\n    #define FXAA_QUALITY_P8 2.0\n    #define FXAA_QUALITY_P9 2.0\n    #define FXAA_QUALITY_P10 4.0\n    #define FXAA_QUALITY_P11 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 39)\n    #define FXAA_QUALITY_PS 12\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.0\n    #define FXAA_QUALITY_P2 1.0\n    #define FXAA_QUALITY_P3 1.0\n    #define FXAA_QUALITY_P4 1.0\n    #define FXAA_QUALITY_P5 1.5\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 2.0\n    #define FXAA_QUALITY_P8 2.0\n    #define FXAA_QUALITY_P9 2.0\n    #define FXAA_QUALITY_P10 4.0\n    #define FXAA_QUALITY_P11 8.0\n#endif\n\n#define FxaaBool bool\n#define FxaaFloat float\n#define FxaaFloat2 vec2\n#define FxaaFloat3 vec3\n#define FxaaFloat4 vec4\n#define FxaaHalf float\n#define FxaaHalf2 vec2\n#define FxaaHalf3 vec3\n#define FxaaHalf4 vec4\n#define FxaaInt2 vec2\n#define FxaaTex sampler2D\n\n#define FxaaSat(x) clamp(x, 0.0, 1.0)\n#define FxaaTexTop(t, p) texture(t, p)\n#define FxaaTexOff(t, p, o, r) texture(t, p + (o * r))\n\nFxaaFloat FxaaLuma_(FxaaFloat4 rgba) { return dot(rgba.rgb, vec3(0.2126, 0.7152, 0.0722)); }\n\nFxaaFloat4 FxaaPixelShader_(\n    //\n    // Use noperspective interpolation here (turn off perspective interpolation).\n    // {xy} = center of pixel\n    FxaaFloat2 pos,\n    //\n    // Input color texture.\n    // {rgb_} = color in linear or perceptual color space\n    // if (FXAA_GREEN_AS_LUMA == 0)\n    //     {___a} = luma in perceptual color space (not linear)\n    FxaaTex tex,\n    //\n    // Only used on FXAA Quality.\n    // This must be from a constant/uniform.\n    // {x_} = 1.0/screenWidthInPixels\n    // {_y} = 1.0/screenHeightInPixels\n    FxaaFloat2 fxaaQualityRcpFrame,\n    //\n    // Only used on FXAA Quality.\n    // This used to be the FXAA_QUALITY_SUBPIX define.\n    // It is here now to allow easier tuning.\n    // Choose the amount of sub-pixel aliasing removal.\n    // This can effect sharpness.\n    //   1.00 - upper limit (softer)\n    //   0.75 - default amount of filtering\n    //   0.50 - lower limit (sharper, less sub-pixel aliasing removal)\n    //   0.25 - almost off\n    //   0.00 - completely off\n    FxaaFloat fxaaQualitySubpix,\n    //\n    // Only used on FXAA Quality.\n    // This used to be the FXAA_QUALITY_EDGE_THRESHOLD define.\n    // It is here now to allow easier tuning.\n    // The minimum amount of local contrast required to apply algorithm.\n    //   0.333 - too little (faster)\n    //   0.250 - low quality\n    //   0.166 - default\n    //   0.125 - high quality\n    //   0.063 - overkill (slower)\n    FxaaFloat fxaaQualityEdgeThreshold,\n    //\n    // Only used on FXAA Quality.\n    // This used to be the FXAA_QUALITY_EDGE_THRESHOLD_MIN define.\n    // It is here now to allow easier tuning.\n    // Trims the algorithm from processing darks.\n    //   0.0833 - upper limit (default, the start of visible unfiltered edges)\n    //   0.0625 - high quality (faster)\n    //   0.0312 - visible limit (slower)\n    // Special notes when using FXAA_GREEN_AS_LUMA,\n    //   Likely want to set this to zero.\n    //   As colors that are mostly not-green\n    //   will appear very dark in the green channel!\n    //   Tune by looking at mostly non-green content,\n    //   then start at zero and increase until aliasing is a problem.\n    FxaaFloat fxaaQualityEdgeThresholdMin\n) {\n/*--------------------------------------------------------------------------*/\n    FxaaFloat2 posM;\n    posM.x = pos.x;\n    posM.y = pos.y;\n    FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);\n    #define lumaM rgbyM.y\n    FxaaFloat lumaS = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 0, 1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaE = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 1, 0), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaN = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 0,-1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaW = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2(-1, 0), fxaaQualityRcpFrame.xy));\n/*--------------------------------------------------------------------------*/\n    FxaaFloat maxSM = max(lumaS, lumaM);\n    FxaaFloat minSM = min(lumaS, lumaM);\n    FxaaFloat maxESM = max(lumaE, maxSM);\n    FxaaFloat minESM = min(lumaE, minSM);\n    FxaaFloat maxWN = max(lumaN, lumaW);\n    FxaaFloat minWN = min(lumaN, lumaW);\n    FxaaFloat rangeMax = max(maxWN, maxESM);\n    FxaaFloat rangeMin = min(minWN, minESM);\n    FxaaFloat rangeMaxScaled = rangeMax * fxaaQualityEdgeThreshold;\n    FxaaFloat range = rangeMax - rangeMin;\n    FxaaFloat rangeMaxClamped = max(fxaaQualityEdgeThresholdMin, rangeMaxScaled);\n    FxaaBool earlyExit = range < rangeMaxClamped;\n/*--------------------------------------------------------------------------*/\n    if(earlyExit)\n        return rgbyM;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat lumaNW = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2(-1,-1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaSE = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 1, 1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaNE = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 1,-1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaSW = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));\n/*--------------------------------------------------------------------------*/\n    FxaaFloat lumaNS = lumaN + lumaS;\n    FxaaFloat lumaWE = lumaW + lumaE;\n    FxaaFloat subpixRcpRange = 1.0/range;\n    FxaaFloat subpixNSWE = lumaNS + lumaWE;\n    FxaaFloat edgeHorz1 = (-2.0 * lumaM) + lumaNS;\n    FxaaFloat edgeVert1 = (-2.0 * lumaM) + lumaWE;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat lumaNESE = lumaNE + lumaSE;\n    FxaaFloat lumaNWNE = lumaNW + lumaNE;\n    FxaaFloat edgeHorz2 = (-2.0 * lumaE) + lumaNESE;\n    FxaaFloat edgeVert2 = (-2.0 * lumaN) + lumaNWNE;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat lumaNWSW = lumaNW + lumaSW;\n    FxaaFloat lumaSWSE = lumaSW + lumaSE;\n    FxaaFloat edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);\n    FxaaFloat edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);\n    FxaaFloat edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;\n    FxaaFloat edgeVert3 = (-2.0 * lumaS) + lumaSWSE;\n    FxaaFloat edgeHorz = abs(edgeHorz3) + edgeHorz4;\n    FxaaFloat edgeVert = abs(edgeVert3) + edgeVert4;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat subpixNWSWNESE = lumaNWSW + lumaNESE;\n    FxaaFloat lengthSign = fxaaQualityRcpFrame.x;\n    FxaaBool horzSpan = edgeHorz >= edgeVert;\n    FxaaFloat subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;\n/*--------------------------------------------------------------------------*/\n    if(!horzSpan) lumaN = lumaW;\n    if(!horzSpan) lumaS = lumaE;\n    if(horzSpan) lengthSign = fxaaQualityRcpFrame.y;\n    FxaaFloat subpixB = (subpixA * (1.0/12.0)) - lumaM;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat gradientN = lumaN - lumaM;\n    FxaaFloat gradientS = lumaS - lumaM;\n    FxaaFloat lumaNN = lumaN + lumaM;\n    FxaaFloat lumaSS = lumaS + lumaM;\n    FxaaBool pairN = abs(gradientN) >= abs(gradientS);\n    FxaaFloat gradient = max(abs(gradientN), abs(gradientS));\n    if(pairN) lengthSign = -lengthSign;\n    FxaaFloat subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);\n/*--------------------------------------------------------------------------*/\n    FxaaFloat2 posB;\n    posB.x = posM.x;\n    posB.y = posM.y;\n    FxaaFloat2 offNP;\n    offNP.x = (!horzSpan) ? 0.0 : fxaaQualityRcpFrame.x;\n    offNP.y = ( horzSpan) ? 0.0 : fxaaQualityRcpFrame.y;\n    if(!horzSpan) posB.x += lengthSign * 0.5;\n    if( horzSpan) posB.y += lengthSign * 0.5;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat2 posN;\n    posN.x = posB.x - offNP.x * FXAA_QUALITY_P0;\n    posN.y = posB.y - offNP.y * FXAA_QUALITY_P0;\n    FxaaFloat2 posP;\n    posP.x = posB.x + offNP.x * FXAA_QUALITY_P0;\n    posP.y = posB.y + offNP.y * FXAA_QUALITY_P0;\n    FxaaFloat subpixD = ((-2.0)*subpixC) + 3.0;\n    FxaaFloat lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN));\n    FxaaFloat subpixE = subpixC * subpixC;\n    FxaaFloat lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP));\n/*--------------------------------------------------------------------------*/\n    if(!pairN) lumaNN = lumaSS;\n    FxaaFloat gradientScaled = gradient * 1.0/4.0;\n    FxaaFloat lumaMM = lumaM - lumaNN * 0.5;\n    FxaaFloat subpixF = subpixD * subpixE;\n    FxaaBool lumaMLTZero = lumaMM < 0.0;\n/*--------------------------------------------------------------------------*/\n    lumaEndN -= lumaNN * 0.5;\n    lumaEndP -= lumaNN * 0.5;\n    FxaaBool doneN = abs(lumaEndN) >= gradientScaled;\n    FxaaBool doneP = abs(lumaEndP) >= gradientScaled;\n    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P1;\n    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P1;\n    FxaaBool doneNP = (!doneN) || (!doneP);\n    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P1;\n    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P1;\n/*--------------------------------------------------------------------------*/\n    if(doneNP) {\n        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n        doneN = abs(lumaEndN) >= gradientScaled;\n        doneP = abs(lumaEndP) >= gradientScaled;\n        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P2;\n        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P2;\n        doneNP = (!doneN) || (!doneP);\n        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P2;\n        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P2;\n/*--------------------------------------------------------------------------*/\n        #if (FXAA_QUALITY_PS > 3)\n        if(doneNP) {\n            if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n            if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n            doneN = abs(lumaEndN) >= gradientScaled;\n            doneP = abs(lumaEndP) >= gradientScaled;\n            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P3;\n            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P3;\n            doneNP = (!doneN) || (!doneP);\n            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P3;\n            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P3;\n/*--------------------------------------------------------------------------*/\n            #if (FXAA_QUALITY_PS > 4)\n            if(doneNP) {\n                if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                doneN = abs(lumaEndN) >= gradientScaled;\n                doneP = abs(lumaEndP) >= gradientScaled;\n                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P4;\n                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P4;\n                doneNP = (!doneN) || (!doneP);\n                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P4;\n                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P4;\n/*--------------------------------------------------------------------------*/\n                #if (FXAA_QUALITY_PS > 5)\n                if(doneNP) {\n                    if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                    if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                    doneN = abs(lumaEndN) >= gradientScaled;\n                    doneP = abs(lumaEndP) >= gradientScaled;\n                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P5;\n                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P5;\n                    doneNP = (!doneN) || (!doneP);\n                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P5;\n                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P5;\n/*--------------------------------------------------------------------------*/\n                    #if (FXAA_QUALITY_PS > 6)\n                    if(doneNP) {\n                        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                        doneN = abs(lumaEndN) >= gradientScaled;\n                        doneP = abs(lumaEndP) >= gradientScaled;\n                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P6;\n                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P6;\n                        doneNP = (!doneN) || (!doneP);\n                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P6;\n                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P6;\n/*--------------------------------------------------------------------------*/\n                        #if (FXAA_QUALITY_PS > 7)\n                        if(doneNP) {\n                            if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                            if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                            doneN = abs(lumaEndN) >= gradientScaled;\n                            doneP = abs(lumaEndP) >= gradientScaled;\n                            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P7;\n                            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P7;\n                            doneNP = (!doneN) || (!doneP);\n                            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P7;\n                            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P7;\n/*--------------------------------------------------------------------------*/\n    #if (FXAA_QUALITY_PS > 8)\n    if(doneNP) {\n        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n        doneN = abs(lumaEndN) >= gradientScaled;\n        doneP = abs(lumaEndP) >= gradientScaled;\n        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P8;\n        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P8;\n        doneNP = (!doneN) || (!doneP);\n        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P8;\n        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P8;\n/*--------------------------------------------------------------------------*/\n        #if (FXAA_QUALITY_PS > 9)\n        if(doneNP) {\n            if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n            if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n            doneN = abs(lumaEndN) >= gradientScaled;\n            doneP = abs(lumaEndP) >= gradientScaled;\n            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P9;\n            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P9;\n            doneNP = (!doneN) || (!doneP);\n            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P9;\n            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P9;\n/*--------------------------------------------------------------------------*/\n            #if (FXAA_QUALITY_PS > 10)\n            if(doneNP) {\n                if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                doneN = abs(lumaEndN) >= gradientScaled;\n                doneP = abs(lumaEndP) >= gradientScaled;\n                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P10;\n                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P10;\n                doneNP = (!doneN) || (!doneP);\n                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P10;\n                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P10;\n/*--------------------------------------------------------------------------*/\n                #if (FXAA_QUALITY_PS > 11)\n                if(doneNP) {\n                    if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                    if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                    doneN = abs(lumaEndN) >= gradientScaled;\n                    doneP = abs(lumaEndP) >= gradientScaled;\n                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P11;\n                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P11;\n                    doneNP = (!doneN) || (!doneP);\n                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P11;\n                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P11;\n/*--------------------------------------------------------------------------*/\n                    #if (FXAA_QUALITY_PS > 12)\n                    if(doneNP) {\n                        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                        doneN = abs(lumaEndN) >= gradientScaled;\n                        doneP = abs(lumaEndP) >= gradientScaled;\n                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P12;\n                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P12;\n                        doneNP = (!doneN) || (!doneP);\n                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P12;\n                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P12;\n/*--------------------------------------------------------------------------*/\n                    }\n                    #endif\n/*--------------------------------------------------------------------------*/\n                }\n                #endif\n/*--------------------------------------------------------------------------*/\n            }\n            #endif\n/*--------------------------------------------------------------------------*/\n        }\n        #endif\n/*--------------------------------------------------------------------------*/\n    }\n    #endif\n/*--------------------------------------------------------------------------*/\n                        }\n                        #endif\n/*--------------------------------------------------------------------------*/\n                    }\n                    #endif\n/*--------------------------------------------------------------------------*/\n                }\n                #endif\n/*--------------------------------------------------------------------------*/\n            }\n            #endif\n/*--------------------------------------------------------------------------*/\n        }\n        #endif\n/*--------------------------------------------------------------------------*/\n    }\n/*--------------------------------------------------------------------------*/\n    FxaaFloat dstN = posM.x - posN.x;\n    FxaaFloat dstP = posP.x - posM.x;\n    if(!horzSpan) dstN = posM.y - posN.y;\n    if(!horzSpan) dstP = posP.y - posM.y;\n/*--------------------------------------------------------------------------*/\n    FxaaBool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;\n    FxaaFloat spanLength = (dstP + dstN);\n    FxaaBool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;\n    FxaaFloat spanLengthRcp = 1.0/spanLength;\n/*--------------------------------------------------------------------------*/\n    FxaaBool directionN = dstN < dstP;\n    FxaaFloat dst = min(dstN, dstP);\n    FxaaBool goodSpan = directionN ? goodSpanN : goodSpanP;\n    FxaaFloat subpixG = subpixF * subpixF;\n    FxaaFloat pixelOffset = (dst * (-spanLengthRcp)) + 0.5;\n    FxaaFloat subpixH = subpixG * fxaaQualitySubpix;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat pixelOffsetGood = goodSpan ? pixelOffset : 0.0;\n    FxaaFloat pixelOffsetSubpix = max(pixelOffsetGood, subpixH);\n    if(!horzSpan) posM.x += pixelOffsetSubpix * lengthSign;\n    if( horzSpan) posM.y += pixelOffsetSubpix * lengthSign;\n    return FxaaTexTop(tex, posM);\n}\n\nvec4 fxaa_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n    const float fxaa_QualitySubpix = 0.5;\n    const float fxaa_QualityEdgeThreshold = 0.125;\n    const float fxaa_QualityEdgeThresholdMin = 0.0833;\n\n    return FxaaPixelShader_(\n        texCoord,\n        source,\n        vec2(1.0) / texSize,\n        fxaa_QualitySubpix,\n        fxaa_QualityEdgeThreshold,\n        fxaa_QualityEdgeThresholdMin\n    );\n}\n`;\n/**\n * FXAA - Fast Approximate Anti-aliasing.\n */\nexport const fxaa = {\n    name: 'fxaa',\n    uniformPropTypes: {},\n    fs,\n    passes: [{ sampler: true }],\n    getUniforms: props => props\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const fp64arithmeticShader = /* glsl */ `\\\nuniform float ONE;\n\n/*\nAbout LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n\nThe purpose of this workaround is to prevent shader compilers from\noptimizing away necessary arithmetic operations by swapping their sequences\nor transform the equation to some 'equivalent' form.\n\nThe method is to multiply an artifical variable, ONE, which will be known to\nthe compiler to be 1 only at runtime. The whole expression is then represented\nas a polynomial with respective to ONE. In the coefficients of all terms, only one a\nand one b should appear\n\nerr = (a + b) * ONE^6 - a * ONE^5 - (a + b) * ONE^4 + a * ONE^3 - b - (a + b) * ONE^2 + a * ONE\n*/\n\n// Divide float number to high and low floats to extend fraction bits\nvec2 split(float a) {\n  const float SPLIT = 4097.0;\n  float t = a * SPLIT;\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  float a_hi = t * ONE - (t - a);\n  float a_lo = a * ONE - a_hi;\n#else\n  float a_hi = t - (t - a);\n  float a_lo = a - a_hi;\n#endif\n  return vec2(a_hi, a_lo);\n}\n\n// Divide float number again when high float uses too many fraction bits\nvec2 split2(vec2 a) {\n  vec2 b = split(a.x);\n  b.y += a.y;\n  return b;\n}\n\n// Special sum operation when a > b\nvec2 quickTwoSum(float a, float b) {\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  float sum = (a + b) * ONE;\n  float err = b - (sum - a) * ONE;\n#else\n  float sum = a + b;\n  float err = b - (sum - a);\n#endif\n  return vec2(sum, err);\n}\n\n// General sum operation\nvec2 twoSum(float a, float b) {\n  float s = (a + b);\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  float v = (s * ONE - a) * ONE;\n  float err = (a - (s - v) * ONE) * ONE * ONE * ONE + (b - v);\n#else\n  float v = s - a;\n  float err = (a - (s - v)) + (b - v);\n#endif\n  return vec2(s, err);\n}\n\nvec2 twoSub(float a, float b) {\n  float s = (a - b);\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  float v = (s * ONE - a) * ONE;\n  float err = (a - (s - v) * ONE) * ONE * ONE * ONE - (b + v);\n#else\n  float v = s - a;\n  float err = (a - (s - v)) - (b + v);\n#endif\n  return vec2(s, err);\n}\n\nvec2 twoSqr(float a) {\n  float prod = a * a;\n  vec2 a_fp64 = split(a);\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  float err = ((a_fp64.x * a_fp64.x - prod) * ONE + 2.0 * a_fp64.x *\n    a_fp64.y * ONE * ONE) + a_fp64.y * a_fp64.y * ONE * ONE * ONE;\n#else\n  float err = ((a_fp64.x * a_fp64.x - prod) + 2.0 * a_fp64.x * a_fp64.y) + a_fp64.y * a_fp64.y;\n#endif\n  return vec2(prod, err);\n}\n\nvec2 twoProd(float a, float b) {\n  float prod = a * b;\n  vec2 a_fp64 = split(a);\n  vec2 b_fp64 = split(b);\n  float err = ((a_fp64.x * b_fp64.x - prod) + a_fp64.x * b_fp64.y +\n    a_fp64.y * b_fp64.x) + a_fp64.y * b_fp64.y;\n  return vec2(prod, err);\n}\n\nvec2 sum_fp64(vec2 a, vec2 b) {\n  vec2 s, t;\n  s = twoSum(a.x, b.x);\n  t = twoSum(a.y, b.y);\n  s.y += t.x;\n  s = quickTwoSum(s.x, s.y);\n  s.y += t.y;\n  s = quickTwoSum(s.x, s.y);\n  return s;\n}\n\nvec2 sub_fp64(vec2 a, vec2 b) {\n  vec2 s, t;\n  s = twoSub(a.x, b.x);\n  t = twoSub(a.y, b.y);\n  s.y += t.x;\n  s = quickTwoSum(s.x, s.y);\n  s.y += t.y;\n  s = quickTwoSum(s.x, s.y);\n  return s;\n}\n\nvec2 mul_fp64(vec2 a, vec2 b) {\n  vec2 prod = twoProd(a.x, b.x);\n  // y component is for the error\n  prod.y += a.x * b.y;\n#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)\n  prod = split2(prod);\n#endif\n  prod = quickTwoSum(prod.x, prod.y);\n  prod.y += a.y * b.x;\n#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)\n  prod = split2(prod);\n#endif\n  prod = quickTwoSum(prod.x, prod.y);\n  return prod;\n}\n\nvec2 div_fp64(vec2 a, vec2 b) {\n  float xn = 1.0 / b.x;\n#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)\n  vec2 yn = mul_fp64(a, vec2(xn, 0));\n#else\n  vec2 yn = a * xn;\n#endif\n  float diff = (sub_fp64(a, mul_fp64(b, yn))).x;\n  vec2 prod = twoProd(xn, diff);\n  return sum_fp64(yn, prod);\n}\n\nvec2 sqrt_fp64(vec2 a) {\n  if (a.x == 0.0 && a.y == 0.0) return vec2(0.0, 0.0);\n  if (a.x < 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);\n\n  float x = 1.0 / sqrt(a.x);\n  float yn = a.x * x;\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  vec2 yn_sqr = twoSqr(yn) * ONE;\n#else\n  vec2 yn_sqr = twoSqr(yn);\n#endif\n  float diff = sub_fp64(a, yn_sqr).x;\n  vec2 prod = twoProd(x * 0.5, diff);\n#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)\n  return sum_fp64(split(yn), prod);\n#else\n  return sum_fp64(vec2(yn, 0.0), prod);\n#endif\n}\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const fp64functionShader = /* glsl */ `\\\nconst vec2 E_FP64 = vec2(2.7182817459106445e+00, 8.254840366817007e-08);\nconst vec2 LOG2_FP64 = vec2(0.6931471824645996e+00, -1.9046542121259336e-09);\nconst vec2 PI_FP64 = vec2(3.1415927410125732, -8.742278012618954e-8);\nconst vec2 TWO_PI_FP64 = vec2(6.2831854820251465, -1.7484556025237907e-7);\nconst vec2 PI_2_FP64 = vec2(1.5707963705062866, -4.371139006309477e-8);\nconst vec2 PI_4_FP64 = vec2(0.7853981852531433, -2.1855695031547384e-8);\nconst vec2 PI_16_FP64 = vec2(0.19634954631328583, -5.463923757886846e-9);\nconst vec2 PI_16_2_FP64 = vec2(0.39269909262657166, -1.0927847515773692e-8);\nconst vec2 PI_16_3_FP64 = vec2(0.5890486240386963, -1.4906100798128818e-9);\nconst vec2 PI_180_FP64 = vec2(0.01745329238474369, 1.3519960498364902e-10);\n\nconst vec2 SIN_TABLE_0_FP64 = vec2(0.19509032368659973, -1.6704714833615242e-9);\nconst vec2 SIN_TABLE_1_FP64 = vec2(0.3826834261417389, 6.22335089017767e-9);\nconst vec2 SIN_TABLE_2_FP64 = vec2(0.5555702447891235, -1.1769521357507529e-8);\nconst vec2 SIN_TABLE_3_FP64 = vec2(0.7071067690849304, 1.2101617041793133e-8);\n\nconst vec2 COS_TABLE_0_FP64 = vec2(0.9807852506637573, 2.9739473106360492e-8);\nconst vec2 COS_TABLE_1_FP64 = vec2(0.9238795042037964, 2.8307490351764386e-8);\nconst vec2 COS_TABLE_2_FP64 = vec2(0.8314695954322815, 1.6870263741530778e-8);\nconst vec2 COS_TABLE_3_FP64 = vec2(0.7071067690849304, 1.2101617152815436e-8);\n\nconst vec2 INVERSE_FACTORIAL_3_FP64 = vec2(1.666666716337204e-01, -4.967053879312289e-09); // 1/3!\nconst vec2 INVERSE_FACTORIAL_4_FP64 = vec2(4.16666679084301e-02, -1.2417634698280722e-09); // 1/4!\nconst vec2 INVERSE_FACTORIAL_5_FP64 = vec2(8.333333767950535e-03, -4.34617203337595e-10); // 1/5!\nconst vec2 INVERSE_FACTORIAL_6_FP64 = vec2(1.3888889225199819e-03, -3.3631094437103215e-11); // 1/6!\nconst vec2 INVERSE_FACTORIAL_7_FP64 = vec2(1.9841270113829523e-04,  -2.725596874933456e-12); // 1/7!\nconst vec2 INVERSE_FACTORIAL_8_FP64 = vec2(2.4801587642286904e-05, -3.406996025904184e-13); // 1/8!\nconst vec2 INVERSE_FACTORIAL_9_FP64 = vec2(2.75573188446287533e-06, 3.7935713937038186e-14); // 1/9!\nconst vec2 INVERSE_FACTORIAL_10_FP64 = vec2(2.755731998149713e-07, -7.575112367869873e-15); // 1/10!\n\nfloat nint(float d) {\n    if (d == floor(d)) return d;\n    return floor(d + 0.5);\n}\n\nvec2 nint_fp64(vec2 a) {\n    float hi = nint(a.x);\n    float lo;\n    vec2 tmp;\n    if (hi == a.x) {\n        lo = nint(a.y);\n        tmp = quickTwoSum(hi, lo);\n    } else {\n        lo = 0.0;\n        if (abs(hi - a.x) == 0.5 && a.y < 0.0) {\n            hi -= 1.0;\n        }\n        tmp = vec2(hi, lo);\n    }\n    return tmp;\n}\n\n/* k_power controls how much range reduction we would like to have\nRange reduction uses the following method:\nassume a = k_power * r + m * log(2), k and m being integers.\nSet k_power = 4 (we can choose other k to trade accuracy with performance.\nwe only need to calculate exp(r) and using exp(a) = 2^m * exp(r)^k_power;\n*/\n\nvec2 exp_fp64(vec2 a) {\n  // We need to make sure these two numbers match\n  // as bit-wise shift is not available in GLSL 1.0\n  const int k_power = 4;\n  const float k = 16.0;\n\n  const float inv_k = 1.0 / k;\n\n  if (a.x <= -88.0) return vec2(0.0, 0.0);\n  if (a.x >= 88.0) return vec2(1.0 / 0.0, 1.0 / 0.0);\n  if (a.x == 0.0 && a.y == 0.0) return vec2(1.0, 0.0);\n  if (a.x == 1.0 && a.y == 0.0) return E_FP64;\n\n  float m = floor(a.x / LOG2_FP64.x + 0.5);\n  vec2 r = sub_fp64(a, mul_fp64(LOG2_FP64, vec2(m, 0.0))) * inv_k;\n  vec2 s, t, p;\n\n  p = mul_fp64(r, r);\n  s = sum_fp64(r, p * 0.5);\n  p = mul_fp64(p, r);\n  t = mul_fp64(p, INVERSE_FACTORIAL_3_FP64);\n\n  s = sum_fp64(s, t);\n  p = mul_fp64(p, r);\n  t = mul_fp64(p, INVERSE_FACTORIAL_4_FP64);\n\n  s = sum_fp64(s, t);\n  p = mul_fp64(p, r);\n  t = mul_fp64(p, INVERSE_FACTORIAL_5_FP64);\n\n  // s = sum_fp64(s, t);\n  // p = mul_fp64(p, r);\n  // t = mul_fp64(p, INVERSE_FACTORIAL_6_FP64);\n\n  // s = sum_fp64(s, t);\n  // p = mul_fp64(p, r);\n  // t = mul_fp64(p, INVERSE_FACTORIAL_7_FP64);\n\n  s = sum_fp64(s, t);\n\n\n  // At this point, s = exp(r) - 1; but after following 4 recursions, we will get exp(r) ^ 512 - 1.\n  for (int i = 0; i < k_power; i++) {\n    s = sum_fp64(s * 2.0, mul_fp64(s, s));\n  }\n\n#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)\n  s = sum_fp64(s, vec2(ONE, 0.0));\n#else\n  s = sum_fp64(s, vec2(1.0, 0.0));\n#endif\n\n  return s * pow(2.0, m);\n//   return r;\n}\n\nvec2 log_fp64(vec2 a)\n{\n  if (a.x == 1.0 && a.y == 0.0) return vec2(0.0, 0.0);\n  if (a.x <= 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);\n  vec2 x = vec2(log(a.x), 0.0);\n  vec2 s;\n#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)\n  s = vec2(ONE, 0.0);\n#else\n  s = vec2(1.0, 0.0);\n#endif\n\n  x = sub_fp64(sum_fp64(x, mul_fp64(a, exp_fp64(-x))), s);\n  return x;\n}\n\nvec2 sin_taylor_fp64(vec2 a) {\n  vec2 r, s, t, x;\n\n  if (a.x == 0.0 && a.y == 0.0) {\n    return vec2(0.0, 0.0);\n  }\n\n  x = -mul_fp64(a, a);\n  s = a;\n  r = a;\n\n  r = mul_fp64(r, x);\n  t = mul_fp64(r, INVERSE_FACTORIAL_3_FP64);\n  s = sum_fp64(s, t);\n\n  r = mul_fp64(r, x);\n  t = mul_fp64(r, INVERSE_FACTORIAL_5_FP64);\n  s = sum_fp64(s, t);\n\n  /* keep the following commented code in case we need them\n  for extra accuracy from the Taylor expansion*/\n\n  // r = mul_fp64(r, x);\n  // t = mul_fp64(r, INVERSE_FACTORIAL_7_FP64);\n  // s = sum_fp64(s, t);\n\n  // r = mul_fp64(r, x);\n  // t = mul_fp64(r, INVERSE_FACTORIAL_9_FP64);\n  // s = sum_fp64(s, t);\n\n  return s;\n}\n\nvec2 cos_taylor_fp64(vec2 a) {\n  vec2 r, s, t, x;\n\n  if (a.x == 0.0 && a.y == 0.0) {\n    return vec2(1.0, 0.0);\n  }\n\n  x = -mul_fp64(a, a);\n  r = x;\n  s = sum_fp64(vec2(1.0, 0.0), r * 0.5);\n\n  r = mul_fp64(r, x);\n  t = mul_fp64(r, INVERSE_FACTORIAL_4_FP64);\n  s = sum_fp64(s, t);\n\n  r = mul_fp64(r, x);\n  t = mul_fp64(r, INVERSE_FACTORIAL_6_FP64);\n  s = sum_fp64(s, t);\n\n  /* keep the following commented code in case we need them\n  for extra accuracy from the Taylor expansion*/\n\n  // r = mul_fp64(r, x);\n  // t = mul_fp64(r, INVERSE_FACTORIAL_8_FP64);\n  // s = sum_fp64(s, t);\n\n  // r = mul_fp64(r, x);\n  // t = mul_fp64(r, INVERSE_FACTORIAL_10_FP64);\n  // s = sum_fp64(s, t);\n\n  return s;\n}\n\nvoid sincos_taylor_fp64(vec2 a, out vec2 sin_t, out vec2 cos_t) {\n  if (a.x == 0.0 && a.y == 0.0) {\n    sin_t = vec2(0.0, 0.0);\n    cos_t = vec2(1.0, 0.0);\n  }\n\n  sin_t = sin_taylor_fp64(a);\n  cos_t = sqrt_fp64(sub_fp64(vec2(1.0, 0.0), mul_fp64(sin_t, sin_t)));\n}\n\nvec2 sin_fp64(vec2 a) {\n    if (a.x == 0.0 && a.y == 0.0) {\n        return vec2(0.0, 0.0);\n    }\n\n    // 2pi range reduction\n    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));\n    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));\n\n    vec2 t;\n    float q = floor(r.x / PI_2_FP64.x + 0.5);\n    int j = int(q);\n\n    if (j < -2 || j > 2) {\n        return vec2(0.0 / 0.0, 0.0 / 0.0);\n    }\n\n    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));\n\n    q = floor(t.x / PI_16_FP64.x + 0.5);\n    int k = int(q);\n\n    if (k == 0) {\n        if (j == 0) {\n            return sin_taylor_fp64(t);\n        } else if (j == 1) {\n            return cos_taylor_fp64(t);\n        } else if (j == -1) {\n            return -cos_taylor_fp64(t);\n        } else {\n            return -sin_taylor_fp64(t);\n        }\n    }\n\n    int abs_k = int(abs(float(k)));\n\n    if (abs_k > 4) {\n        return vec2(0.0 / 0.0, 0.0 / 0.0);\n    } else {\n        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));\n    }\n\n    vec2 u = vec2(0.0, 0.0);\n    vec2 v = vec2(0.0, 0.0);\n\n#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)\n    if (abs(float(abs_k) - 1.0) < 0.5) {\n        u = COS_TABLE_0_FP64;\n        v = SIN_TABLE_0_FP64;\n    } else if (abs(float(abs_k) - 2.0) < 0.5) {\n        u = COS_TABLE_1_FP64;\n        v = SIN_TABLE_1_FP64;\n    } else if (abs(float(abs_k) - 3.0) < 0.5) {\n        u = COS_TABLE_2_FP64;\n        v = SIN_TABLE_2_FP64;\n    } else if (abs(float(abs_k) - 4.0) < 0.5) {\n        u = COS_TABLE_3_FP64;\n        v = SIN_TABLE_3_FP64;\n    }\n#else\n    if (abs_k == 1) {\n        u = COS_TABLE_0_FP64;\n        v = SIN_TABLE_0_FP64;\n    } else if (abs_k == 2) {\n        u = COS_TABLE_1_FP64;\n        v = SIN_TABLE_1_FP64;\n    } else if (abs_k == 3) {\n        u = COS_TABLE_2_FP64;\n        v = SIN_TABLE_2_FP64;\n    } else if (abs_k == 4) {\n        u = COS_TABLE_3_FP64;\n        v = SIN_TABLE_3_FP64;\n    }\n#endif\n\n    vec2 sin_t, cos_t;\n    sincos_taylor_fp64(t, sin_t, cos_t);\n\n\n\n    vec2 result = vec2(0.0, 0.0);\n    if (j == 0) {\n        if (k > 0) {\n            result = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));\n        } else {\n            result = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));\n        }\n    } else if (j == 1) {\n        if (k > 0) {\n            result = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));\n        } else {\n            result = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));\n        }\n    } else if (j == -1) {\n        if (k > 0) {\n            result = sub_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));\n        } else {\n            result = -sum_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));\n        }\n    } else {\n        if (k > 0) {\n            result = -sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));\n        } else {\n            result = sub_fp64(mul_fp64(v, cos_t), mul_fp64(u, sin_t));\n        }\n    }\n\n    return result;\n}\n\nvec2 cos_fp64(vec2 a) {\n    if (a.x == 0.0 && a.y == 0.0) {\n        return vec2(1.0, 0.0);\n    }\n\n    // 2pi range reduction\n    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));\n    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));\n\n    vec2 t;\n    float q = floor(r.x / PI_2_FP64.x + 0.5);\n    int j = int(q);\n\n    if (j < -2 || j > 2) {\n        return vec2(0.0 / 0.0, 0.0 / 0.0);\n    }\n\n    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));\n\n    q = floor(t.x / PI_16_FP64.x + 0.5);\n    int k = int(q);\n\n    if (k == 0) {\n        if (j == 0) {\n            return cos_taylor_fp64(t);\n        } else if (j == 1) {\n            return -sin_taylor_fp64(t);\n        } else if (j == -1) {\n            return sin_taylor_fp64(t);\n        } else {\n            return -cos_taylor_fp64(t);\n        }\n    }\n\n    int abs_k = int(abs(float(k)));\n\n    if (abs_k > 4) {\n        return vec2(0.0 / 0.0, 0.0 / 0.0);\n    } else {\n        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));\n    }\n\n    vec2 u = vec2(0.0, 0.0);\n    vec2 v = vec2(0.0, 0.0);\n\n#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)\n    if (abs(float(abs_k) - 1.0) < 0.5) {\n        u = COS_TABLE_0_FP64;\n        v = SIN_TABLE_0_FP64;\n    } else if (abs(float(abs_k) - 2.0) < 0.5) {\n        u = COS_TABLE_1_FP64;\n        v = SIN_TABLE_1_FP64;\n    } else if (abs(float(abs_k) - 3.0) < 0.5) {\n        u = COS_TABLE_2_FP64;\n        v = SIN_TABLE_2_FP64;\n    } else if (abs(float(abs_k) - 4.0) < 0.5) {\n        u = COS_TABLE_3_FP64;\n        v = SIN_TABLE_3_FP64;\n    }\n#else\n    if (abs_k == 1) {\n        u = COS_TABLE_0_FP64;\n        v = SIN_TABLE_0_FP64;\n    } else if (abs_k == 2) {\n        u = COS_TABLE_1_FP64;\n        v = SIN_TABLE_1_FP64;\n    } else if (abs_k == 3) {\n        u = COS_TABLE_2_FP64;\n        v = SIN_TABLE_2_FP64;\n    } else if (abs_k == 4) {\n        u = COS_TABLE_3_FP64;\n        v = SIN_TABLE_3_FP64;\n    }\n#endif\n\n    vec2 sin_t, cos_t;\n    sincos_taylor_fp64(t, sin_t, cos_t);\n\n    vec2 result = vec2(0.0, 0.0);\n    if (j == 0) {\n        if (k > 0) {\n            result = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));\n        } else {\n            result = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));\n        }\n    } else if (j == 1) {\n        if (k > 0) {\n            result = -sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));\n        } else {\n            result = sub_fp64(mul_fp64(v, cos_t), mul_fp64(u, sin_t));\n        }\n    } else if (j == -1) {\n        if (k > 0) {\n            result = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));\n        } else {\n            result = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));\n        }\n    } else {\n        if (k > 0) {\n            result = sub_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));\n        } else {\n            result = -sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));\n        }\n    }\n\n    return result;\n}\n\nvec2 tan_fp64(vec2 a) {\n    vec2 sin_a;\n    vec2 cos_a;\n\n    if (a.x == 0.0 && a.y == 0.0) {\n        return vec2(0.0, 0.0);\n    }\n\n    // 2pi range reduction\n    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));\n    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));\n\n    vec2 t;\n    float q = floor(r.x / PI_2_FP64.x + 0.5);\n    int j = int(q);\n\n\n    if (j < -2 || j > 2) {\n        return vec2(0.0 / 0.0, 0.0 / 0.0);\n    }\n\n    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));\n\n    q = floor(t.x / PI_16_FP64.x + 0.5);\n    int k = int(q);\n    int abs_k = int(abs(float(k)));\n\n    // We just can't get PI/16 * 3.0 very accurately.\n    // so let's just store it\n    if (abs_k > 4) {\n        return vec2(0.0 / 0.0, 0.0 / 0.0);\n    } else {\n        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));\n    }\n\n\n    vec2 u = vec2(0.0, 0.0);\n    vec2 v = vec2(0.0, 0.0);\n\n    vec2 sin_t, cos_t;\n    vec2 s, c;\n    sincos_taylor_fp64(t, sin_t, cos_t);\n\n    if (k == 0) {\n        s = sin_t;\n        c = cos_t;\n    } else {\n#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)\n        if (abs(float(abs_k) - 1.0) < 0.5) {\n            u = COS_TABLE_0_FP64;\n            v = SIN_TABLE_0_FP64;\n        } else if (abs(float(abs_k) - 2.0) < 0.5) {\n            u = COS_TABLE_1_FP64;\n            v = SIN_TABLE_1_FP64;\n        } else if (abs(float(abs_k) - 3.0) < 0.5) {\n            u = COS_TABLE_2_FP64;\n            v = SIN_TABLE_2_FP64;\n        } else if (abs(float(abs_k) - 4.0) < 0.5) {\n            u = COS_TABLE_3_FP64;\n            v = SIN_TABLE_3_FP64;\n        }\n#else\n        if (abs_k == 1) {\n            u = COS_TABLE_0_FP64;\n            v = SIN_TABLE_0_FP64;\n        } else if (abs_k == 2) {\n            u = COS_TABLE_1_FP64;\n            v = SIN_TABLE_1_FP64;\n        } else if (abs_k == 3) {\n            u = COS_TABLE_2_FP64;\n            v = SIN_TABLE_2_FP64;\n        } else if (abs_k == 4) {\n            u = COS_TABLE_3_FP64;\n            v = SIN_TABLE_3_FP64;\n        }\n#endif\n        if (k > 0) {\n            s = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));\n            c = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));\n        } else {\n            s = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));\n            c = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));\n        }\n    }\n\n    if (j == 0) {\n        sin_a = s;\n        cos_a = c;\n    } else if (j == 1) {\n        sin_a = c;\n        cos_a = -s;\n    } else if (j == -1) {\n        sin_a = -c;\n        cos_a = s;\n    } else {\n        sin_a = -s;\n        cos_a = -c;\n    }\n    return div_fp64(sin_a, cos_a);\n}\n\nvec2 radians_fp64(vec2 degree) {\n  return mul_fp64(degree, PI_180_FP64);\n}\n\nvec2 mix_fp64(vec2 a, vec2 b, float x) {\n  vec2 range = sub_fp64(b, a);\n  return sum_fp64(a, mul_fp64(range, vec2(x, 0.0)));\n}\n\n// Vector functions\n// vec2 functions\nvoid vec2_sum_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {\n    out_val[0] = sum_fp64(a[0], b[0]);\n    out_val[1] = sum_fp64(a[1], b[1]);\n}\n\nvoid vec2_sub_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {\n    out_val[0] = sub_fp64(a[0], b[0]);\n    out_val[1] = sub_fp64(a[1], b[1]);\n}\n\nvoid vec2_mul_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {\n    out_val[0] = mul_fp64(a[0], b[0]);\n    out_val[1] = mul_fp64(a[1], b[1]);\n}\n\nvoid vec2_div_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {\n    out_val[0] = div_fp64(a[0], b[0]);\n    out_val[1] = div_fp64(a[1], b[1]);\n}\n\nvoid vec2_mix_fp64(vec2 x[2], vec2 y[2], float a, out vec2 out_val[2]) {\n  vec2 range[2];\n  vec2_sub_fp64(y, x, range);\n  vec2 portion[2];\n  portion[0] = range[0] * a;\n  portion[1] = range[1] * a;\n  vec2_sum_fp64(x, portion, out_val);\n}\n\nvec2 vec2_length_fp64(vec2 x[2]) {\n  return sqrt_fp64(sum_fp64(mul_fp64(x[0], x[0]), mul_fp64(x[1], x[1])));\n}\n\nvoid vec2_normalize_fp64(vec2 x[2], out vec2 out_val[2]) {\n  vec2 length = vec2_length_fp64(x);\n  vec2 length_vec2[2];\n  length_vec2[0] = length;\n  length_vec2[1] = length;\n\n  vec2_div_fp64(x, length_vec2, out_val);\n}\n\nvec2 vec2_distance_fp64(vec2 x[2], vec2 y[2]) {\n  vec2 diff[2];\n  vec2_sub_fp64(x, y, diff);\n  return vec2_length_fp64(diff);\n}\n\nvec2 vec2_dot_fp64(vec2 a[2], vec2 b[2]) {\n  vec2 v[2];\n\n  v[0] = mul_fp64(a[0], b[0]);\n  v[1] = mul_fp64(a[1], b[1]);\n\n  return sum_fp64(v[0], v[1]);\n}\n\n// vec3 functions\nvoid vec3_sub_fp64(vec2 a[3], vec2 b[3], out vec2 out_val[3]) {\n  for (int i = 0; i < 3; i++) {\n    out_val[i] = sum_fp64(a[i], b[i]);\n  }\n}\n\nvoid vec3_sum_fp64(vec2 a[3], vec2 b[3], out vec2 out_val[3]) {\n  for (int i = 0; i < 3; i++) {\n    out_val[i] = sum_fp64(a[i], b[i]);\n  }\n}\n\nvec2 vec3_length_fp64(vec2 x[3]) {\n  return sqrt_fp64(sum_fp64(sum_fp64(mul_fp64(x[0], x[0]), mul_fp64(x[1], x[1])),\n    mul_fp64(x[2], x[2])));\n}\n\nvec2 vec3_distance_fp64(vec2 x[3], vec2 y[3]) {\n  vec2 diff[3];\n  vec3_sub_fp64(x, y, diff);\n  return vec3_length_fp64(diff);\n}\n\n// vec4 functions\nvoid vec4_fp64(vec4 a, out vec2 out_val[4]) {\n  out_val[0].x = a[0];\n  out_val[0].y = 0.0;\n\n  out_val[1].x = a[1];\n  out_val[1].y = 0.0;\n\n  out_val[2].x = a[2];\n  out_val[2].y = 0.0;\n\n  out_val[3].x = a[3];\n  out_val[3].y = 0.0;\n}\n\nvoid vec4_scalar_mul_fp64(vec2 a[4], vec2 b, out vec2 out_val[4]) {\n  out_val[0] = mul_fp64(a[0], b);\n  out_val[1] = mul_fp64(a[1], b);\n  out_val[2] = mul_fp64(a[2], b);\n  out_val[3] = mul_fp64(a[3], b);\n}\n\nvoid vec4_sum_fp64(vec2 a[4], vec2 b[4], out vec2 out_val[4]) {\n  for (int i = 0; i < 4; i++) {\n    out_val[i] = sum_fp64(a[i], b[i]);\n  }\n}\n\nvoid vec4_dot_fp64(vec2 a[4], vec2 b[4], out vec2 out_val) {\n  vec2 v[4];\n\n  v[0] = mul_fp64(a[0], b[0]);\n  v[1] = mul_fp64(a[1], b[1]);\n  v[2] = mul_fp64(a[2], b[2]);\n  v[3] = mul_fp64(a[3], b[3]);\n\n  out_val = sum_fp64(sum_fp64(v[0], v[1]), sum_fp64(v[2], v[3]));\n}\n\nvoid mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {\n  vec2 tmp[4];\n\n  for (int i = 0; i < 4; i++)\n  {\n    for (int j = 0; j < 4; j++)\n    {\n      tmp[j] = b[j + i * 4];\n    }\n    vec4_dot_fp64(a, tmp, out_val[i]);\n  }\n}\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { fp64ify, fp64LowPart, fp64ifyMatrix4 } from \"../../../modules/math/fp64/fp64-utils.js\";\nimport { fp64arithmeticShader } from \"./fp64-arithmetic-glsl.js\";\nimport { fp64functionShader } from \"./fp64-functions-glsl.js\";\nconst CONST_UNIFORMS = {\n    // Used in LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n    ONE: 1.0\n};\nexport { fp64ify, fp64LowPart, fp64ifyMatrix4 };\nfunction getUniforms() {\n    return CONST_UNIFORMS;\n}\n/**\n * 64bit arithmetic: add, sub, mul, div (small subset of fp64 module)\n */\nexport const fp64arithmetic = {\n    name: 'fp64-arithmetic',\n    vs: fp64arithmeticShader,\n    getUniforms,\n    fp64ify,\n    fp64LowPart,\n    fp64ifyMatrix4\n};\n/**\n * Full 64 bit math library\n */\nexport const fp64 = {\n    name: 'fp64',\n    vs: fp64functionShader,\n    dependencies: [fp64arithmetic],\n    // Additional Functions\n    fp64ify,\n    fp64LowPart,\n    fp64ifyMatrix4\n};\n", "// import {ShaderModule} from '../../types';\n// TODO - reuse normal from geometry module\nconst vs = /* glsl */ `\\\nvarying vec4 geometry_vPosition;\nvarying vec3 geometry_vNormal;\n\nvoid geometry_setNormal(vec3 normal) {\n  geometry_vNormal = normal;\n}\n\nvoid geometry_setPosition(vec4 position) {\n  geometry_vPosition = position;\n}\n\nvoid geometry_setPosition(vec3 position) {\n  geometry_vPosition = vec4(position, 1.);\n}\n`;\nconst fs = /* glsl */ `\\\nvarying vec4 geometry_vPosition;\nvarying vec3 geometry_vNormal;\n\nvec4 geometry_getPosition() {\n  return geometry_vPosition;\n}\n\nvec3 geometry_getNormal() {\n  return geometry_vNormal;\n}\n`;\n/**\n * Geometry varyings\n */\nexport const geometry = {\n    name: 'geometry',\n    vs,\n    fs\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { Matrix4 } from '@math.gl/core';\nconst IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];\nconst DEFAULT_MODULE_OPTIONS = {\n    modelMatrix: IDENTITY_MATRIX,\n    viewMatrix: IDENTITY_MATRIX,\n    projectionMatrix: IDENTITY_MATRIX,\n    cameraPositionWorld: [0, 0, 0]\n};\nfunction getUniforms(opts = DEFAULT_MODULE_OPTIONS, prevUniforms = {}) {\n    // const viewProjectionInverse = viewProjection.invert();\n    // viewInverseMatrix: view.invert(),\n    // viewProjectionInverseMatrix: viewProjectionInverse\n    const uniforms = {};\n    if (opts.modelMatrix !== undefined) {\n        uniforms.modelMatrix = opts.modelMatrix;\n    }\n    if (opts.viewMatrix !== undefined) {\n        uniforms.viewMatrix = opts.viewMatrix;\n    }\n    if (opts.projectionMatrix !== undefined) {\n        uniforms.projectionMatrix = opts.projectionMatrix;\n    }\n    if (opts.cameraPositionWorld !== undefined) {\n        uniforms.cameraPositionWorld = opts.cameraPositionWorld;\n    }\n    // COMPOSITE UNIFORMS\n    if (opts.projectionMatrix !== undefined && opts.viewMatrix !== undefined) {\n        uniforms.viewProjectionMatrix = new Matrix4(opts.projectionMatrix).multiplyRight(opts.viewMatrix);\n    }\n    return uniforms;\n}\nconst common = /* glsl */ `\\\nvarying vec4 project_vPositionWorld;\nvarying vec3 project_vNormalWorld;\n\nvec4 project_getPosition_World() {\n  return project_vPositionWorld;\n}\n\nvec3 project_getNormal_World() {\n  return project_vNormalWorld;\n}\n`;\nconst vs = `\\\n${common}\n\n// Unprefixed uniforms\nuniform mat4 modelMatrix;\nuniform mat4 viewMatrix;\nuniform mat4 projectionMatrix;\nuniform mat4 viewProjectionMatrix;\nuniform vec3 cameraPositionWorld;\n\nstruct World {\n  vec3 position;\n  vec3 normal;\n};\n\nWorld world;\n\nvoid project_setPosition(vec4 position) {\n  project_vPositionWorld = position;\n}\n\nvoid project_setNormal(vec3 normal) {\n  project_vNormalWorld = normal;\n}\n\nvoid project_setPositionAndNormal_World(vec3 position, vec3 normal) {\n  world.position = position;\n  world.normal = normal;\n}\n\nvoid project_setPositionAndNormal_Model(vec3 position, vec3 normal) {\n  world.position = (modelMatrix * vec4(position, 1.)).xyz;\n  world.normal = mat3(modelMatrix) * normal;\n}\n\nvec4 project_model_to_clipspace(vec4 position) {\n  return viewProjectionMatrix * modelMatrix * position;\n}\n\nvec4 project_model_to_clipspace(vec3 position) {\n  return viewProjectionMatrix * modelMatrix * vec4(position, 1.);\n}\n\nvec4 project_world_to_clipspace(vec3 position) {\n  return viewProjectionMatrix * vec4(position, 1.);\n}\n\nvec4 project_view_to_clipspace(vec3 position) {\n  return projectionMatrix * vec4(position, 1.);\n}\n\nvec4 project_to_clipspace(vec3 position) {\n  return viewProjectionMatrix * vec4(position, 1.);\n}\n`;\nconst fs = `\n${common}\\\n`;\n/**\n * Projects coordinates\n */\nexport const project = {\n    name: 'project',\n    getUniforms,\n    vs,\n    fs\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const lightingShader = /* glsl */ `\\\n#if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))\n\nstruct AmbientLight {\n vec3 color;\n};\n\nstruct PointLight {\n vec3 color;\n vec3 position;\n\n // Constant-Linear-Exponential\n vec3 attenuation;\n};\n\nstruct DirectionalLight {\n  vec3 color;\n  vec3 direction;\n};\n\nuniform AmbientLight lighting_uAmbientLight;\nuniform PointLight lighting_uPointLight[MAX_LIGHTS];\nuniform DirectionalLight lighting_uDirectionalLight[MAX_LIGHTS];\nuniform int lighting_uPointLightCount;\nuniform int lighting_uDirectionalLightCount;\n\nuniform bool lighting_uEnabled;\n\nfloat getPointLightAttenuation(PointLight pointLight, float distance) {\n  return pointLight.attenuation.x\n       + pointLight.attenuation.y * distance\n       + pointLight.attenuation.z * distance * distance;\n}\n\n#endif\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { lightingShader } from \"./lights-glsl.js\";\nconst INITIAL_MODULE_OPTIONS = {\n    lightSources: {}\n};\n// Take color 0-255 and intensity as input and output 0.0-1.0 range\nfunction convertColor(colorDef = {}) {\n    const { color = [0, 0, 0], intensity = 1.0 } = colorDef;\n    return color.map(component => (component * intensity) / 255.0);\n}\nfunction getLightSourceUniforms({ ambientLight, pointLights = [], directionalLights = [] }) {\n    const lightSourceUniforms = {};\n    if (ambientLight) {\n        lightSourceUniforms['lighting_uAmbientLight.color'] = convertColor(ambientLight);\n    }\n    else {\n        lightSourceUniforms['lighting_uAmbientLight.color'] = [0, 0, 0];\n    }\n    pointLights.forEach((pointLight, index) => {\n        lightSourceUniforms[`lighting_uPointLight[${index}].color`] = convertColor(pointLight);\n        lightSourceUniforms[`lighting_uPointLight[${index}].position`] = pointLight.position;\n        lightSourceUniforms[`lighting_uPointLight[${index}].attenuation`] = pointLight.attenuation || [\n            1, 0, 0\n        ];\n    });\n    lightSourceUniforms.lighting_uPointLightCount = pointLights.length;\n    directionalLights.forEach((directionalLight, index) => {\n        lightSourceUniforms[`lighting_uDirectionalLight[${index}].color`] =\n            convertColor(directionalLight);\n        lightSourceUniforms[`lighting_uDirectionalLight[${index}].direction`] =\n            directionalLight.direction;\n    });\n    lightSourceUniforms.lighting_uDirectionalLightCount = directionalLights.length;\n    return lightSourceUniforms;\n}\n// eslint-disable-next-line complexity\nfunction getUniforms(opts = INITIAL_MODULE_OPTIONS) {\n    // Specify lights separately\n    if ('lightSources' in opts) {\n        const { ambientLight, pointLights, directionalLights } = opts.lightSources || {};\n        const hasLights = ambientLight ||\n            (pointLights && pointLights.length > 0) ||\n            (directionalLights && directionalLights.length > 0);\n        if (!hasLights) {\n            return { lighting_uEnabled: false };\n        }\n        return Object.assign({}, getLightSourceUniforms({ ambientLight, pointLights, directionalLights }), {\n            lighting_uEnabled: true\n        });\n    }\n    // Support for array of lights. Type of light is detected by type field\n    if ('lights' in opts) {\n        const lightSources = { pointLights: [], directionalLights: [] };\n        // @ts-expect-error\n        for (const light of opts.lights || []) {\n            switch (light.type) {\n                case 'ambient':\n                    // Note: Only uses last ambient light\n                    // TODO - add ambient light sources on CPU?\n                    lightSources.ambientLight = light;\n                    break;\n                case 'directional':\n                    lightSources.directionalLights?.push(light);\n                    break;\n                case 'point':\n                    lightSources.pointLights?.push(light);\n                    break;\n                default:\n                // eslint-disable-next-line\n                // console.warn(light.type);\n            }\n        }\n        // Call the `opts.lightSources`` version\n        return getUniforms({ lightSources });\n    }\n    return {};\n}\n/**\n * An implementation of PBR (Physically-Based Rendering).\n * Physically Based Shading of a microfacet surface defined by a glTF material.\n */\nexport const lights = {\n    name: 'lights',\n    vs: lightingShader,\n    fs: lightingShader,\n    getUniforms,\n    defines: {\n        MAX_LIGHTS: 3\n    }\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { project } from \"../../project/project.js\";\nconst DEFAULT_MODULE_OPTIONS = {\n    lightDirection: new Float32Array([1, 1, 2])\n};\nfunction getUniforms(opts = DEFAULT_MODULE_OPTIONS) {\n    const uniforms = {};\n    if (opts.lightDirection) {\n        // @ts-expect-error TODO add types\n        uniforms.dirlight_uLightDirection = opts.lightDirection;\n    }\n    return uniforms;\n}\nconst fs = /* glsl */ `\\\nuniform vec3 dirlight_uLightDirection;\n\n/*\n * Returns color attenuated by angle from light source\n */\nvec4 dirlight_filterColor(vec4 color) {\n  vec3 normal = project_getNormal_World();\n  float d = abs(dot(normalize(normal), normalize(dirlight_uLightDirection)));\n  return vec4(color.rgb * d, color.a);\n}\n`;\n/**\n * Cheap lighting - single directional light, single dot product, one uniform\n */\nexport const dirlight = {\n    name: 'dirlight',\n    // vs // TODO - reuse normal from geometry module\n    fs,\n    getUniforms,\n    dependencies: [project]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const lightingShader = /* glsl */ `\\\n\nuniform float lighting_uAmbient;\nuniform float lighting_uDiffuse;\nuniform float lighting_uShininess;\nuniform vec3  lighting_uSpecularColor;\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {\n    vec3 halfway_direction = normalize(light_direction + view_direction);\n    float lambertian = dot(light_direction, normal_worldspace);\n    float specular = 0.0;\n    if (lambertian > 0.0) {\n      float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);\n      specular = pow(specular_angle, lighting_uShininess);\n    }\n    lambertian = max(lambertian, 0.0);\n    return (lambertian * lighting_uDiffuse * surfaceColor + specular * lighting_uSpecularColor) * color;\n}\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = surfaceColor;\n\n  if (lighting_uEnabled) {\n    vec3 view_direction = normalize(cameraPosition - position_worldspace);\n    lightColor = lighting_uAmbient * surfaceColor * lighting_uAmbientLight.color;\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting_uPointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_uPointLight[i];\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting_uDirectionalLightCount) {\n        break;\n      }\n      DirectionalLight directionalLight = lighting_uDirectionalLight[i];\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n  }\n  return lightColor;\n}\n\nvec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = vec3(0, 0, 0);\n  vec3 surfaceColor = vec3(0, 0, 0);\n\n  if (lighting_uEnabled) {\n    vec3 view_direction = normalize(cameraPosition - position_worldspace);\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting_uPointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_uPointLight[i];\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting_uDirectionalLightCount) {\n        break;\n      }\n      DirectionalLight directionalLight = lighting_uDirectionalLight[i];\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n  }\n  return lightColor;\n}\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { lights } from \"../lights/lights.js\";\nimport { lightingShader } from \"./phong-lighting-glsl.js\";\nconst INITIAL_MODULE_OPTIONS = {};\nfunction getMaterialUniforms(material) {\n    const { ambient = 0.35, diffuse = 0.6, shininess = 32, specularColor = [30, 30, 30] } = material;\n    return {\n        lighting_uAmbient: ambient,\n        lighting_uDiffuse: diffuse,\n        lighting_uShininess: shininess,\n        lighting_uSpecularColor: specularColor.map(x => x / 255)\n    };\n}\nfunction getUniforms(opts = INITIAL_MODULE_OPTIONS) {\n    if (!('material' in opts)) {\n        return {};\n    }\n    const { material } = opts;\n    if (!material) {\n        return { lighting_uEnabled: false };\n    }\n    return getMaterialUniforms(material);\n}\nexport const gouraudLighting = {\n    name: 'gouraud-lighting',\n    dependencies: [lights],\n    vs: lightingShader,\n    defines: {\n        LIGHTING_VERTEX: 1\n    },\n    getUniforms\n};\nexport const phongLighting = {\n    name: 'phong-lighting',\n    dependencies: [lights],\n    fs: lightingShader,\n    defines: {\n        LIGHTING_FRAGMENT: 1\n    },\n    getUniforms\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const vs = /* glsl */ `\\\nuniform mat4 u_MVPMatrix;\nuniform mat4 u_ModelMatrix;\nuniform mat4 u_NormalMatrix;\n\nout vec3 pbr_vPosition;\nout vec2 pbr_vUV;\n\n#ifdef HAS_NORMALS\n# ifdef HAS_TANGENTS\nout mat3 pbr_vTBN;\n# else\nout vec3 pbr_vNormal;\n# endif\n#endif\n\nvoid pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)\n{\n  vec4 pos = u_ModelMatrix * position;\n  pbr_vPosition = vec3(pos.xyz) / pos.w;\n\n#ifdef HAS_NORMALS\n#ifdef HAS_TANGENTS\n  vec3 normalW = normalize(vec3(u_NormalMatrix * vec4(normal.xyz, 0.0)));\n  vec3 tangentW = normalize(vec3(u_ModelMatrix * vec4(tangent.xyz, 0.0)));\n  vec3 bitangentW = cross(normalW, tangentW) * tangent.w;\n  pbr_vTBN = mat3(tangentW, bitangentW, normalW);\n#else // HAS_TANGENTS != 1\n  pbr_vNormal = normalize(vec3(u_ModelMatrix * vec4(normal.xyz, 0.0)));\n#endif\n#endif\n\n#ifdef HAS_UV\n  pbr_vUV = uv;\n#else\n  pbr_vUV = vec2(0.,0.);\n#endif\n}\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// Attribution:\n// MIT license, Copyright (c) 2016-2017 Mohamad Moneimne and Contributors\n// This fragment shader defines a reference implementation for Physically Based Shading of\n// a microfacet surface material defined by a glTF model.\n//\n// TODO - better do the checks outside of shader\nexport const fs = /* glsl */ `\\\nprecision highp float;\n\nuniform bool pbr_uUnlit;\n\n#ifdef USE_IBL\nuniform samplerCube u_DiffuseEnvSampler;\nuniform samplerCube u_SpecularEnvSampler;\nuniform sampler2D u_brdfLUT;\nuniform vec2 u_ScaleIBLAmbient;\n#endif\n\n#ifdef HAS_BASECOLORMAP\nuniform sampler2D u_BaseColorSampler;\n#endif\n#ifdef HAS_NORMALMAP\nuniform sampler2D u_NormalSampler;\nuniform float u_NormalScale;\n#endif\n#ifdef HAS_EMISSIVEMAP\nuniform sampler2D u_EmissiveSampler;\nuniform vec3 u_EmissiveFactor;\n#endif\n#ifdef HAS_METALROUGHNESSMAP\nuniform sampler2D u_MetallicRoughnessSampler;\n#endif\n#ifdef HAS_OCCLUSIONMAP\nuniform sampler2D u_OcclusionSampler;\nuniform float u_OcclusionStrength;\n#endif\n\n#ifdef ALPHA_CUTOFF\nuniform float u_AlphaCutoff;\n#endif\n\nuniform vec2 u_MetallicRoughnessValues;\nuniform vec4 u_BaseColorFactor;\n\nuniform vec3 u_Camera;\n\n// debugging flags used for shader output of intermediate PBR variables\n#ifdef PBR_DEBUG\nuniform vec4 u_ScaleDiffBaseMR;\nuniform vec4 u_ScaleFGDSpec;\n#endif\n\nin vec3 pbr_vPosition;\n\nin vec2 pbr_vUV;\n\n#ifdef HAS_NORMALS\n#ifdef HAS_TANGENTS\nin mat3 pbr_vTBN;\n#else\nin vec3 pbr_vNormal;\n#endif\n#endif\n\n// Encapsulate the various inputs used by the various functions in the shading equation\n// We store values in this struct to simplify the integration of alternative implementations\n// of the shading terms, outlined in the Readme.MD Appendix.\nstruct PBRInfo\n{\n  float NdotL;                  // cos angle between normal and light direction\n  float NdotV;                  // cos angle between normal and view direction\n  float NdotH;                  // cos angle between normal and half vector\n  float LdotH;                  // cos angle between light direction and half vector\n  float VdotH;                  // cos angle between view direction and half vector\n  float perceptualRoughness;    // roughness value, as authored by the model creator (input to shader)\n  float metalness;              // metallic value at the surface\n  vec3 reflectance0;            // full reflectance color (normal incidence angle)\n  vec3 reflectance90;           // reflectance color at grazing angle\n  float alphaRoughness;         // roughness mapped to a more linear change in the roughness (proposed by [2])\n  vec3 diffuseColor;            // color contribution from diffuse lighting\n  vec3 specularColor;           // color contribution from specular lighting\n  vec3 n;                       // normal at surface point\n  vec3 v;                       // vector from surface point to camera\n};\n\nconst float M_PI = 3.141592653589793;\nconst float c_MinRoughness = 0.04;\n\nvec4 SRGBtoLINEAR(vec4 srgbIn)\n{\n#ifdef MANUAL_SRGB\n#ifdef SRGB_FAST_APPROXIMATION\n  vec3 linOut = pow(srgbIn.xyz,vec3(2.2));\n#else //SRGB_FAST_APPROXIMATION\n  vec3 bLess = step(vec3(0.04045),srgbIn.xyz);\n  vec3 linOut = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );\n#endif //SRGB_FAST_APPROXIMATION\n  return vec4(linOut,srgbIn.w);;\n#else //MANUAL_SRGB\n  return srgbIn;\n#endif //MANUAL_SRGB\n}\n\n// Find the normal for this fragment, pulling either from a predefined normal map\n// or from the interpolated mesh normal and tangent attributes.\nvec3 getNormal()\n{\n  // Retrieve the tangent space matrix\n#ifndef HAS_TANGENTS\n  vec3 pos_dx = dFdx(pbr_vPosition);\n  vec3 pos_dy = dFdy(pbr_vPosition);\n  vec3 tex_dx = dFdx(vec3(pbr_vUV, 0.0));\n  vec3 tex_dy = dFdy(vec3(pbr_vUV, 0.0));\n  vec3 t = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);\n\n#ifdef HAS_NORMALS\n  vec3 ng = normalize(pbr_vNormal);\n#else\n  vec3 ng = cross(pos_dx, pos_dy);\n#endif\n\n  t = normalize(t - ng * dot(ng, t));\n  vec3 b = normalize(cross(ng, t));\n  mat3 tbn = mat3(t, b, ng);\n#else // HAS_TANGENTS\n  mat3 tbn = pbr_vTBN;\n#endif\n\n#ifdef HAS_NORMALMAP\n  vec3 n = texture(u_NormalSampler, pbr_vUV).rgb;\n  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(u_NormalScale, u_NormalScale, 1.0)));\n#else\n  // The tbn matrix is linearly interpolated, so we need to re-normalize\n  vec3 n = normalize(tbn[2].xyz);\n#endif\n\n  return n;\n}\n\n// Calculation of the lighting contribution from an optional Image Based Light source.\n// Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].\n// See our README.md on Environment Maps [3] for additional discussion.\n#ifdef USE_IBL\nvec3 getIBLContribution(PBRInfo pbrInputs, vec3 n, vec3 reflection)\n{\n  float mipCount = 9.0; // resolution of 512x512\n  float lod = (pbrInputs.perceptualRoughness * mipCount);\n  // retrieve a scale and bias to F0. See [1], Figure 3\n  vec3 brdf = SRGBtoLINEAR(texture(u_brdfLUT,\n    vec2(pbrInputs.NdotV, 1.0 - pbrInputs.perceptualRoughness))).rgb;\n  vec3 diffuseLight = SRGBtoLINEAR(textureCube(u_DiffuseEnvSampler, n)).rgb;\n\n#ifdef USE_TEX_LOD\n  vec3 specularLight = SRGBtoLINEAR(textureCubeLod(u_SpecularEnvSampler, reflection, lod)).rgb;\n#else\n  vec3 specularLight = SRGBtoLINEAR(textureCube(u_SpecularEnvSampler, reflection)).rgb;\n#endif\n\n  vec3 diffuse = diffuseLight * pbrInputs.diffuseColor;\n  vec3 specular = specularLight * (pbrInputs.specularColor * brdf.x + brdf.y);\n\n  // For presentation, this allows us to disable IBL terms\n  diffuse *= u_ScaleIBLAmbient.x;\n  specular *= u_ScaleIBLAmbient.y;\n\n  return diffuse + specular;\n}\n#endif\n\n// Basic Lambertian diffuse\n// Implementation from Lambert's Photometria https://archive.org/details/lambertsphotome00lambgoog\n// See also [1], Equation 1\nvec3 diffuse(PBRInfo pbrInputs)\n{\n  return pbrInputs.diffuseColor / M_PI;\n}\n\n// The following equation models the Fresnel reflectance term of the spec equation (aka F())\n// Implementation of fresnel from [4], Equation 15\nvec3 specularReflection(PBRInfo pbrInputs)\n{\n  return pbrInputs.reflectance0 +\n    (pbrInputs.reflectance90 - pbrInputs.reflectance0) *\n    pow(clamp(1.0 - pbrInputs.VdotH, 0.0, 1.0), 5.0);\n}\n\n// This calculates the specular geometric attenuation (aka G()),\n// where rougher material will reflect less light back to the viewer.\n// This implementation is based on [1] Equation 4, and we adopt their modifications to\n// alphaRoughness as input as originally proposed in [2].\nfloat geometricOcclusion(PBRInfo pbrInputs)\n{\n  float NdotL = pbrInputs.NdotL;\n  float NdotV = pbrInputs.NdotV;\n  float r = pbrInputs.alphaRoughness;\n\n  float attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));\n  float attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));\n  return attenuationL * attenuationV;\n}\n\n// The following equation(s) model the distribution of microfacet normals across\n// the area being drawn (aka D())\n// Implementation from \"Average Irregularity Representation of a Roughened Surface\n// for Ray Reflection\" by T. S. Trowbridge, and K. P. Reitz\n// Follows the distribution function recommended in the SIGGRAPH 2013 course notes\n// from EPIC Games [1], Equation 3.\nfloat microfacetDistribution(PBRInfo pbrInputs)\n{\n  float roughnessSq = pbrInputs.alphaRoughness * pbrInputs.alphaRoughness;\n  float f = (pbrInputs.NdotH * roughnessSq - pbrInputs.NdotH) * pbrInputs.NdotH + 1.0;\n  return roughnessSq / (M_PI * f * f);\n}\n\nvoid PBRInfo_setAmbientLight(inout PBRInfo pbrInputs) {\n  pbrInputs.NdotL = 1.0;\n  pbrInputs.NdotH = 0.0;\n  pbrInputs.LdotH = 0.0;\n  pbrInputs.VdotH = 1.0;\n}\n\nvoid PBRInfo_setDirectionalLight(inout PBRInfo pbrInputs, vec3 lightDirection) {\n  vec3 n = pbrInputs.n;\n  vec3 v = pbrInputs.v;\n  vec3 l = normalize(lightDirection);             // Vector from surface point to light\n  vec3 h = normalize(l+v);                        // Half vector between both l and v\n\n  pbrInputs.NdotL = clamp(dot(n, l), 0.001, 1.0);\n  pbrInputs.NdotH = clamp(dot(n, h), 0.0, 1.0);\n  pbrInputs.LdotH = clamp(dot(l, h), 0.0, 1.0);\n  pbrInputs.VdotH = clamp(dot(v, h), 0.0, 1.0);\n}\n\nvoid PBRInfo_setPointLight(inout PBRInfo pbrInputs, PointLight pointLight) {\n  vec3 light_direction = normalize(pointLight.position - pbr_vPosition);\n  PBRInfo_setDirectionalLight(pbrInputs, light_direction);\n}\n\nvec3 calculateFinalColor(PBRInfo pbrInputs, vec3 lightColor) {\n  // Calculate the shading terms for the microfacet specular shading model\n  vec3 F = specularReflection(pbrInputs);\n  float G = geometricOcclusion(pbrInputs);\n  float D = microfacetDistribution(pbrInputs);\n\n  // Calculation of analytical lighting contribution\n  vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInputs);\n  vec3 specContrib = F * G * D / (4.0 * pbrInputs.NdotL * pbrInputs.NdotV);\n  // Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)\n  return pbrInputs.NdotL * lightColor * (diffuseContrib + specContrib);\n}\n\nvec4 pbr_filterColor(vec4 colorUnused)\n{\n  // The albedo may be defined from a base texture or a flat color\n#ifdef HAS_BASECOLORMAP\n  vec4 baseColor = SRGBtoLINEAR(texture(u_BaseColorSampler, pbr_vUV)) * u_BaseColorFactor;\n#else\n  vec4 baseColor = u_BaseColorFactor;\n#endif\n\n#ifdef ALPHA_CUTOFF\n  if (baseColor.a < u_AlphaCutoff) {\n    discard;\n  }\n#endif\n\n  vec3 color = vec3(0, 0, 0);\n\n  if(pbr_uUnlit){\n    color.rgb = baseColor.rgb;\n  }\n  else{\n    // Metallic and Roughness material properties are packed together\n    // In glTF, these factors can be specified by fixed scalar values\n    // or from a metallic-roughness map\n    float perceptualRoughness = u_MetallicRoughnessValues.y;\n    float metallic = u_MetallicRoughnessValues.x;\n#ifdef HAS_METALROUGHNESSMAP\n    // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.\n    // This layout intentionally reserves the 'r' channel for (optional) occlusion map data\n    vec4 mrSample = texture(u_MetallicRoughnessSampler, pbr_vUV);\n    perceptualRoughness = mrSample.g * perceptualRoughness;\n    metallic = mrSample.b * metallic;\n#endif\n    perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);\n    metallic = clamp(metallic, 0.0, 1.0);\n    // Roughness is authored as perceptual roughness; as is convention,\n    // convert to material roughness by squaring the perceptual roughness [2].\n    float alphaRoughness = perceptualRoughness * perceptualRoughness;\n\n    vec3 f0 = vec3(0.04);\n    vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);\n    diffuseColor *= 1.0 - metallic;\n    vec3 specularColor = mix(f0, baseColor.rgb, metallic);\n\n    // Compute reflectance.\n    float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);\n\n    // For typical incident reflectance range (between 4% to 100%) set the grazing\n    // reflectance to 100% for typical fresnel effect.\n    // For very low reflectance range on highly diffuse objects (below 4%),\n    // incrementally reduce grazing reflecance to 0%.\n    float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);\n    vec3 specularEnvironmentR0 = specularColor.rgb;\n    vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;\n\n    vec3 n = getNormal();                          // normal at surface point\n    vec3 v = normalize(u_Camera - pbr_vPosition);  // Vector from surface point to camera\n\n    float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);\n    vec3 reflection = -normalize(reflect(v, n));\n\n    PBRInfo pbrInputs = PBRInfo(\n      0.0, // NdotL\n      NdotV,\n      0.0, // NdotH\n      0.0, // LdotH\n      0.0, // VdotH\n      perceptualRoughness,\n      metallic,\n      specularEnvironmentR0,\n      specularEnvironmentR90,\n      alphaRoughness,\n      diffuseColor,\n      specularColor,\n      n,\n      v\n    );\n\n#ifdef USE_LIGHTS\n    // Apply ambient light\n    PBRInfo_setAmbientLight(pbrInputs);\n    color += calculateFinalColor(pbrInputs, lighting_uAmbientLight.color);\n\n    // Apply directional light\n    for(int i = 0; i < lighting_uDirectionalLightCount; i++) {\n      if (i < lighting_uDirectionalLightCount) {\n        PBRInfo_setDirectionalLight(pbrInputs, lighting_uDirectionalLight[i].direction);\n        color += calculateFinalColor(pbrInputs, lighting_uDirectionalLight[i].color);\n      }\n    }\n\n    // Apply point light\n    for(int i = 0; i < lighting_uPointLightCount; i++) {\n      if (i < lighting_uPointLightCount) {\n        PBRInfo_setPointLight(pbrInputs, lighting_uPointLight[i]);\n        float attenuation = getPointLightAttenuation(lighting_uPointLight[i], distance(lighting_uPointLight[i].position, pbr_vPosition));\n        color += calculateFinalColor(pbrInputs, lighting_uPointLight[i].color / attenuation);\n      }\n    }\n#endif\n\n    // Calculate lighting contribution from image based lighting source (IBL)\n#ifdef USE_IBL\n    color += getIBLContribution(pbrInputs, n, reflection);\n#endif\n\n    // Apply optional PBR terms for additional (optional) shading\n#ifdef HAS_OCCLUSIONMAP\n    float ao = texture(u_OcclusionSampler, pbr_vUV).r;\n    color = mix(color, color * ao, u_OcclusionStrength);\n#endif\n\n#ifdef HAS_EMISSIVEMAP\n    vec3 emissive = SRGBtoLINEAR(texture(u_EmissiveSampler, pbr_vUV)).rgb * u_EmissiveFactor;\n    color += emissive;\n#endif\n\n    // This section uses mix to override final color for reference app visualization\n    // of various parameters in the lighting equation.\n#ifdef PBR_DEBUG\n    // TODO: Figure out how to debug multiple lights\n\n    // color = mix(color, F, u_ScaleFGDSpec.x);\n    // color = mix(color, vec3(G), u_ScaleFGDSpec.y);\n    // color = mix(color, vec3(D), u_ScaleFGDSpec.z);\n    // color = mix(color, specContrib, u_ScaleFGDSpec.w);\n\n    // color = mix(color, diffuseContrib, u_ScaleDiffBaseMR.x);\n    color = mix(color, baseColor.rgb, u_ScaleDiffBaseMR.y);\n    color = mix(color, vec3(metallic), u_ScaleDiffBaseMR.z);\n    color = mix(color, vec3(perceptualRoughness), u_ScaleDiffBaseMR.w);\n#endif\n\n  }\n\n  return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);\n}\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { lights } from \"../lights/lights.js\";\nimport { vs } from \"./pbr-vertex-glsl.js\";\nimport { fs } from \"./pbr-fragment-glsl.js\";\n/**\n * An implementation of PBR (Physically-Based Rendering).\n * Physically Based Shading of a microfacet surface defined by a glTF material.\n */\nexport const pbr = {\n    name: 'pbr',\n    vs,\n    fs,\n    defines: {\n        LIGHTING_FRAGMENT: 1\n    },\n    dependencies: [lights],\n    getUniforms: (props) => props\n};\n"],
-  "mappings": "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;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA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AA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwkBJ,IAAM,OAAO;AAAA,EAChB,MAAM;AAAA,EACN,kBAAkB,CAAC;AAAA,EACnB,IAAAA;AAAA,EACA,QAAQ,CAAC,EAAE,SAAS,KAAK,CAAC;AAAA,EAC1B,aAAa,WAAS;AAC1B;;;ACxqBO,IAAM;AAAA;AAAA,EAAkC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAxC,IAAM;AAAA;AAAA,EAAgC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA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AAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACCtB,IAAM,MAAM;AAAA,EACf,MAAM;AAAA,EACN,IAAAC;AAAA,EACA,IAAAC;AAAA,EACA,SAAS;AAAA,IACL,mBAAmB;AAAA,EACvB;AAAA,EACA,cAAc,CAAC,MAAM;AAAA,EACrB,aAAa,CAAC,UAAU;AAC5B;",
+  "sources": ["index.js", "lib/utils/assert.js", "lib/filters/prop-types.js", "module-injectors.js", "lib/shader-assembly/shader-injections.js", "lib/shader-module/shader-module.js", "lib/shader-module/shader-module-dependencies.js", "lib/shader-assembly/platform-defines.js", "lib/shader-transpiler/transpile-glsl-shader.js", "lib/shader-assembly/shader-hooks.js", "lib/glsl-utils/get-shader-info.js", "lib/shader-assembly/assemble-shaders.js", "lib/preprocessor/preprocessor.js", "lib/shader-assembler.js", "lib/glsl-utils/shader-utils.js", "lib/shader-generator/utils/capitalize.js", "lib/shader-generator/glsl/generate-glsl.js", "lib/shader-generator/wgsl/generate-wgsl.js", "lib/shader-generator/generate-shader.js", "lib/wgsl/get-shader-layout-wgsl.js", "modules/math/fp16/fp16-utils.js", "modules/math/fp64/fp64-utils.js", "modules/math/random/random.js", "modules/math/fp32/fp32.js", "modules/engine/picking/picking.js", "modules/lighting/lights/lighting-uniforms-glsl.js", "modules/lighting/lights/lighting-uniforms-wgsl.js", "modules/lighting/lights/lighting.js", "modules/lighting/no-material/dirlight.js", "modules/lighting/gouraud-material/gouraud-shaders-glsl.js", "modules/lighting/gouraud-material/gouraud-material.js", "modules/lighting/phong-material/phong-shaders-wgsl.js", "modules/lighting/phong-material/phong-shaders-glsl.js", "modules/lighting/phong-material/phong-material.js", "modules/lighting/pbr-material/pbr-vertex-glsl.js", "modules/lighting/pbr-material/pbr-fragment-glsl.js", "modules/lighting/pbr-material/pbr-material.js", "modules/postprocessing/image-adjust-filters/brightnesscontrast.js", "modules/postprocessing/image-adjust-filters/denoise.js", "modules/postprocessing/image-adjust-filters/huesaturation.js", "modules/postprocessing/image-adjust-filters/noise.js", "modules/postprocessing/image-adjust-filters/sepia.js", "modules/postprocessing/image-adjust-filters/vibrance.js", "modules/postprocessing/image-adjust-filters/vignette.js", "modules/postprocessing/image-blur-filters/tiltshift.js", "modules/postprocessing/image-blur-filters/triangleblur.js", "modules/postprocessing/image-blur-filters/zoomblur.js", "modules/postprocessing/image-fun-filters/colorhalftone.js", "modules/postprocessing/image-fun-filters/dotscreen.js", "modules/postprocessing/image-fun-filters/edgework.js", "modules/postprocessing/image-fun-filters/hexagonalpixelate.js", "modules/postprocessing/image-fun-filters/ink.js", "modules/postprocessing/image-fun-filters/magnify.js", "modules/postprocessing/image-warp-filters/warp.js", "modules/postprocessing/image-warp-filters/bulgepinch.js", "modules/postprocessing/image-warp-filters/swirl.js", "modules/postprocessing/fxaa/fxaa.js", "modules-webgl1/math/fp64/fp64-arithmetic-glsl.js", "modules-webgl1/math/fp64/fp64-functions-glsl.js", "modules-webgl1/math/fp64/fp64.js", "modules-webgl1/geometry/geometry.js", "modules-webgl1/project/project.js", "modules-webgl1/lighting/lights/lights-glsl.js", "modules-webgl1/lighting/lights/lights.js", "modules-webgl1/lighting/dirlight/dirlight.js", "modules-webgl1/lighting/phong-lighting/phong-lighting-glsl.js", "modules-webgl1/lighting/phong-lighting/phong-lighting.js", "modules-webgl1/lighting/pbr/pbr-vertex-glsl.js", "modules-webgl1/lighting/pbr/pbr-fragment-glsl.js", "modules-webgl1/lighting/pbr/pbr.js"],
+  "sourcesContent": ["// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport { initializeShaderModule, initializeShaderModules } from \"./lib/shader-module/shader-module.js\";\nexport { getShaderModuleUniforms } from \"./lib/shader-module/shader-module.js\";\nexport { getShaderModuleDependencies } from \"./lib/shader-module/shader-module-dependencies.js\";\nexport { checkShaderModuleDeprecations } from \"./lib/shader-module/shader-module.js\";\nexport { getShaderModuleSource } from \"./lib/shader-assembly/assemble-shaders.js\";\nexport { resolveModules as _resolveModules } from \"./lib/shader-module/shader-module-dependencies.js\";\nexport { getDependencyGraph as _getDependencyGraph } from \"./lib/shader-module/shader-module-dependencies.js\";\n// ShaderAssembler\nexport { ShaderAssembler } from \"./lib/shader-assembler.js\";\n// SHADER HELPERS\n// Shader source introspection\nexport { getShaderInfo } from \"./lib/glsl-utils/get-shader-info.js\";\nexport { getQualifierDetails, getPassthroughFS, typeToChannelSuffix, typeToChannelCount, convertToVec4 } from \"./lib/glsl-utils/shader-utils.js\";\nexport { generateShaderForModule } from \"./lib/shader-generator/generate-shader.js\";\nexport { capitalize } from \"./lib/shader-generator/utils/capitalize.js\";\n// TEST EXPORTS - Do not use in production applications\nexport { preprocess } from \"./lib/preprocessor/preprocessor.js\";\nexport { assembleGLSLShaderPair } from \"./lib/shader-assembly/assemble-shaders.js\";\nexport { combineInjects } from \"./lib/shader-assembly/shader-injections.js\";\n// EXPERIMENTAL WGSL\nexport { getShaderLayoutFromWGSL } from \"./lib/wgsl/get-shader-layout-wgsl.js\";\n// data utils\nexport { toHalfFloat, fromHalfFloat } from \"./modules/math/fp16/fp16-utils.js\";\nexport { fp64ify, fp64LowPart, fp64ifyMatrix4 } from \"./modules/math/fp64/fp64-utils.js\";\n// math libraries\nexport { random } from \"./modules/math/random/random.js\";\nexport { fp32 } from \"./modules/math/fp32/fp32.js\";\nexport { picking } from \"./modules/engine/picking/picking.js\";\nexport { lighting } from \"./modules/lighting/lights/lighting.js\";\nexport { dirlight } from \"./modules/lighting/no-material/dirlight.js\";\nexport { gouraudMaterial } from \"./modules/lighting/gouraud-material/gouraud-material.js\";\nexport { phongMaterial } from \"./modules/lighting/phong-material/phong-material.js\";\n// export type {PBRMaterialSettings, PBRMaterialUniforms} from './modules/lighting/pbr-material/pbr';\nexport { pbrMaterial } from \"./modules/lighting/pbr-material/pbr-material.js\";\nexport { brightnessContrast } from \"./modules/postprocessing/image-adjust-filters/brightnesscontrast.js\";\nexport { denoise } from \"./modules/postprocessing/image-adjust-filters/denoise.js\";\nexport { hueSaturation } from \"./modules/postprocessing/image-adjust-filters/huesaturation.js\";\nexport { noise } from \"./modules/postprocessing/image-adjust-filters/noise.js\";\nexport { sepia } from \"./modules/postprocessing/image-adjust-filters/sepia.js\";\nexport { vibrance } from \"./modules/postprocessing/image-adjust-filters/vibrance.js\";\nexport { vignette } from \"./modules/postprocessing/image-adjust-filters/vignette.js\";\nexport { tiltShift } from \"./modules/postprocessing/image-blur-filters/tiltshift.js\";\nexport { triangleBlur } from \"./modules/postprocessing/image-blur-filters/triangleblur.js\";\nexport { zoomBlur } from \"./modules/postprocessing/image-blur-filters/zoomblur.js\";\nexport { colorHalftone } from \"./modules/postprocessing/image-fun-filters/colorhalftone.js\";\nexport { dotScreen } from \"./modules/postprocessing/image-fun-filters/dotscreen.js\";\nexport { edgeWork } from \"./modules/postprocessing/image-fun-filters/edgework.js\";\nexport { hexagonalPixelate } from \"./modules/postprocessing/image-fun-filters/hexagonalpixelate.js\";\nexport { ink } from \"./modules/postprocessing/image-fun-filters/ink.js\";\nexport { magnify } from \"./modules/postprocessing/image-fun-filters/magnify.js\";\nexport { bulgePinch } from \"./modules/postprocessing/image-warp-filters/bulgepinch.js\";\nexport { swirl } from \"./modules/postprocessing/image-warp-filters/swirl.js\";\n// Postprocessing modules\n// export type {FXAAProps, FXAAUniforms} from './modules/postprocessing/fxaa/fxaa';\nexport { fxaa } from \"./modules/postprocessing/fxaa/fxaa.js\";\nexport { warp as _warp } from \"./modules/postprocessing/image-warp-filters/warp.js\";\n// DEPRECATED - v8 legacy shader modules (non-uniform buffer)\n// math libraries\nexport { fp64, fp64arithmetic } from \"./modules-webgl1/math/fp64/fp64.js\";\n// projection and lighting\nexport { geometry as geometry1 } from \"./modules-webgl1/geometry/geometry.js\";\nexport { project as project1 } from \"./modules-webgl1/project/project.js\";\nexport { lights as lights1 } from \"./modules-webgl1/lighting/lights/lights.js\";\nexport { dirlight as dirlight1 } from \"./modules-webgl1/lighting/dirlight/dirlight.js\";\nexport { gouraudLighting, phongLighting } from \"./modules-webgl1/lighting/phong-lighting/phong-lighting.js\";\nexport { pbr } from \"./modules-webgl1/lighting/pbr/pbr.js\";\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// Recommendation is to ignore message but current test suite checks agains the\n// message so keep it for now.\nexport function assert(condition, message) {\n    if (!condition) {\n        throw new Error(message || 'shadertools: assertion failed.');\n    }\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { assert } from \"../utils/assert.js\";\n/** Minimal validators for number and array types */\nconst DEFAULT_PROP_VALIDATORS = {\n    number: {\n        type: 'number',\n        validate(value, propType) {\n            return (Number.isFinite(value) &&\n                typeof propType === 'object' &&\n                (propType.max === undefined || value <= propType.max) &&\n                (propType.min === undefined || value >= propType.min));\n        }\n    },\n    array: {\n        type: 'array',\n        validate(value, propType) {\n            return Array.isArray(value) || ArrayBuffer.isView(value);\n        }\n    }\n};\n/**\n * Parse a list of property types into property definitions that can be used to validate\n * values passed in by applications.\n * @param propTypes\n * @returns\n */\nexport function makePropValidators(propTypes) {\n    const propValidators = {};\n    for (const [name, propType] of Object.entries(propTypes)) {\n        propValidators[name] = makePropValidator(propType);\n    }\n    return propValidators;\n}\n/**\n * Validate a map of user supplied properties against a map of validators\n * Inject default values when user doesn't supply a property\n * @param properties\n * @param propValidators\n * @returns\n */\nexport function getValidatedProperties(properties, propValidators, errorMessage) {\n    const validated = {};\n    for (const [key, propsValidator] of Object.entries(propValidators)) {\n        if (properties && key in properties && !propsValidator.private) {\n            if (propsValidator.validate) {\n                assert(propsValidator.validate(properties[key], propsValidator), `${errorMessage}: invalid ${key}`);\n            }\n            validated[key] = properties[key];\n        }\n        else {\n            // property not supplied - use default value\n            validated[key] = propsValidator.value;\n        }\n    }\n    // TODO - warn for unused properties that don't match a validator?\n    return validated;\n}\n/**\n * Creates a property validator for a prop type. Either contains:\n * - a valid prop type object ({type, ...})\n * - or just a default value, in which case type and name inference is used\n */\nfunction makePropValidator(propType) {\n    let type = getTypeOf(propType);\n    if (type !== 'object') {\n        return { value: propType, ...DEFAULT_PROP_VALIDATORS[type], type };\n    }\n    // Special handling for objects\n    if (typeof propType === 'object') {\n        if (!propType) {\n            return { type: 'object', value: null };\n        }\n        if (propType.type !== undefined) {\n            return { ...propType, ...DEFAULT_PROP_VALIDATORS[propType.type], type: propType.type };\n        }\n        // If no type and value this object is likely the value\n        if (propType.value === undefined) {\n            return { type: 'object', value: propType };\n        }\n        type = getTypeOf(propType.value);\n        return { ...propType, ...DEFAULT_PROP_VALIDATORS[type], type };\n    }\n    throw new Error('props');\n}\n/**\n * \"improved\" version of javascript typeof that can distinguish arrays and null values\n */\nfunction getTypeOf(value) {\n    if (Array.isArray(value) || ArrayBuffer.isView(value)) {\n        return 'array';\n    }\n    return typeof value;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const MODULE_INJECTORS_VS = /* glsl */ `\\\n#ifdef MODULE_LOGDEPTH\n  logdepth_adjustPosition(gl_Position);\n#endif\n`;\nexport const MODULE_INJECTORS_FS = /* glsl */ `\\\n#ifdef MODULE_MATERIAL\n  gl_FragColor = material_filterColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_LIGHTING\n  gl_FragColor = lighting_filterColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_FOG\n  gl_FragColor = fog_filterColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_PICKING\n  gl_FragColor = picking_filterHighlightColor(gl_FragColor);\n  gl_FragColor = picking_filterPickingColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_LOGDEPTH\n  logdepth_setFragDepth();\n#endif\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { MODULE_INJECTORS_VS, MODULE_INJECTORS_FS } from \"../../module-injectors.js\";\nimport { assert } from \"../utils/assert.js\";\n// TODO - experimental\nconst MODULE_INJECTORS = {\n    vertex: MODULE_INJECTORS_VS,\n    fragment: MODULE_INJECTORS_FS\n};\nconst REGEX_START_OF_MAIN = /void\\s+main\\s*\\([^)]*\\)\\s*\\{\\n?/; // Beginning of main\nconst REGEX_END_OF_MAIN = /}\\n?[^{}]*$/; // End of main, assumes main is last function\nconst fragments = [];\nexport const DECLARATION_INJECT_MARKER = '__LUMA_INJECT_DECLARATIONS__';\n/**\n *\n */\nexport function normalizeInjections(injections) {\n    const result = { vertex: {}, fragment: {} };\n    for (const hook in injections) {\n        let injection = injections[hook];\n        const stage = getHookStage(hook);\n        if (typeof injection === 'string') {\n            injection = {\n                order: 0,\n                injection\n            };\n        }\n        result[stage][hook] = injection;\n    }\n    return result;\n}\nfunction getHookStage(hook) {\n    const type = hook.slice(0, 2);\n    switch (type) {\n        case 'vs':\n            return 'vertex';\n        case 'fs':\n            return 'fragment';\n        default:\n            throw new Error(type);\n    }\n}\n/**\n// A minimal shader injection/templating system.\n// RFC: https://github.com/visgl/luma.gl/blob/7.0-release/dev-docs/RFCs/v6.0/shader-injection-rfc.md\n * @param source\n * @param type\n * @param inject\n * @param injectStandardStubs\n * @returns\n */\n// eslint-disable-next-line complexity\nexport function injectShader(source, stage, inject, injectStandardStubs = false) {\n    const isVertex = stage === 'vertex';\n    for (const key in inject) {\n        const fragmentData = inject[key];\n        fragmentData.sort((a, b) => a.order - b.order);\n        fragments.length = fragmentData.length;\n        for (let i = 0, len = fragmentData.length; i < len; ++i) {\n            fragments[i] = fragmentData[i].injection;\n        }\n        const fragmentString = `${fragments.join('\\n')}\\n`;\n        switch (key) {\n            // declarations are injected before the main function\n            case 'vs:#decl':\n                if (isVertex) {\n                    source = source.replace(DECLARATION_INJECT_MARKER, fragmentString);\n                }\n                break;\n            // inject code at the beginning of the main function\n            case 'vs:#main-start':\n                if (isVertex) {\n                    source = source.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);\n                }\n                break;\n            // inject code at the end of main function\n            case 'vs:#main-end':\n                if (isVertex) {\n                    source = source.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);\n                }\n                break;\n            // declarations are injected before the main function\n            case 'fs:#decl':\n                if (!isVertex) {\n                    source = source.replace(DECLARATION_INJECT_MARKER, fragmentString);\n                }\n                break;\n            // inject code at the beginning of the main function\n            case 'fs:#main-start':\n                if (!isVertex) {\n                    source = source.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);\n                }\n                break;\n            // inject code at the end of main function\n            case 'fs:#main-end':\n                if (!isVertex) {\n                    source = source.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);\n                }\n                break;\n            default:\n                // TODO(Tarek): I think this usage should be deprecated.\n                // inject code after key, leaving key in place\n                source = source.replace(key, (match) => match + fragmentString);\n        }\n    }\n    // Remove if it hasn't already been replaced\n    source = source.replace(DECLARATION_INJECT_MARKER, '');\n    // Finally, if requested, insert an automatic module injector chunk\n    if (injectStandardStubs) {\n        source = source.replace(/\\}\\s*$/, (match) => match + MODULE_INJECTORS[stage]);\n    }\n    return source;\n}\n// Takes an array of inject objects and combines them into one\nexport function combineInjects(injects) {\n    const result = {};\n    assert(Array.isArray(injects) && injects.length > 1);\n    injects.forEach(inject => {\n        for (const key in inject) {\n            result[key] = result[key] ? `${result[key]}\\n${inject[key]}` : inject[key];\n        }\n    });\n    return result;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { makePropValidators, getValidatedProperties } from \"../filters/prop-types.js\";\nimport { normalizeInjections } from \"../shader-assembly/shader-injections.js\";\n// SHNDER MODULE API\nexport function initializeShaderModules(modules) {\n    modules.map((module) => initializeShaderModule(module));\n}\nexport function initializeShaderModule(module) {\n    if (module.instance) {\n        return;\n    }\n    initializeShaderModules(module.dependencies || []);\n    const { uniformPropTypes = {}, deprecations = [], \n    // defines = {},\n    inject = {} } = module;\n    const instance = {\n        normalizedInjections: normalizeInjections(inject),\n        parsedDeprecations: parseDeprecationDefinitions(deprecations)\n    };\n    if (uniformPropTypes) {\n        instance.propValidators = makePropValidators(uniformPropTypes);\n    }\n    module.instance = instance;\n}\n/** Convert module props to uniforms */\nexport function getShaderModuleUniforms(module, props, oldUniforms) {\n    initializeShaderModule(module);\n    const uniforms = oldUniforms || { ...module.defaultUniforms };\n    // If module has a getUniforms function, use it\n    if (module.getUniforms) {\n        return module.getUniforms(props, uniforms);\n    }\n    // Build uniforms from the uniforms array\n    // @ts-expect-error\n    return getValidatedProperties(props, module.instance?.propValidators, module.name);\n}\n/* TODO this looks like it was unused code\n  _defaultGetUniforms(opts: Record<string, any> = {}): Record<string, any> {\n    const uniforms: Record<string, any> = {};\n    const propTypes = this.uniforms;\n\n    for (const key in propTypes) {\n      const propDef = propTypes[key];\n      if (key in opts && !propDef.private) {\n        if (propDef.validate) {\n          assert(propDef.validate(opts[key], propDef), `${this.name}: invalid ${key}`);\n        }\n        uniforms[key] = opts[key];\n      } else {\n        uniforms[key] = propDef.value;\n      }\n    }\n\n    return uniforms;\n  }\n}\n*/\n// Warn about deprecated uniforms or functions\nexport function checkShaderModuleDeprecations(shaderModule, shaderSource, log) {\n    shaderModule.deprecations?.forEach(def => {\n        if (def.regex?.test(shaderSource)) {\n            if (def.deprecated) {\n                log.deprecated(def.old, def.new)();\n            }\n            else {\n                log.removed(def.old, def.new)();\n            }\n        }\n    });\n}\n// HELPERS\nfunction parseDeprecationDefinitions(deprecations) {\n    deprecations.forEach(def => {\n        switch (def.type) {\n            case 'function':\n                def.regex = new RegExp(`\\\\b${def.old}\\\\(`);\n                break;\n            default:\n                def.regex = new RegExp(`${def.type} ${def.old};`);\n        }\n    });\n    return deprecations;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { initializeShaderModules } from \"./shader-module.js\";\n/**\n * Takes a list of shader module names and returns a new list of\n * shader module names that includes all dependencies, sorted so\n * that modules that are dependencies of other modules come first.\n *\n * If the shader glsl code from the returned modules is concatenated\n * in the reverse order, it is guaranteed that all functions be resolved and\n * that all function and variable definitions come before use.\n *\n * @param modules - Array of modules (inline modules or module names)\n * @return - Array of modules\n */\nexport function getShaderModuleDependencies(modules) {\n    initializeShaderModules(modules);\n    const moduleMap = {};\n    const moduleDepth = {};\n    getDependencyGraph({ modules, level: 0, moduleMap, moduleDepth });\n    // Return a reverse sort so that dependencies come before the modules that use them\n    const dependencies = Object.keys(moduleDepth)\n        .sort((a, b) => moduleDepth[b] - moduleDepth[a])\n        .map(name => moduleMap[name]);\n    initializeShaderModules(dependencies);\n    return dependencies;\n}\n/**\n * Recursively checks module dependencies to calculate dependency level of each module.\n *\n * @param options.modules - Array of modules\n * @param options.level - Current level\n * @param options.moduleMap -\n * @param options.moduleDepth - Current level\n * @return - Map of module name to its level\n */\n// Adds another level of dependencies to the result map\nexport function getDependencyGraph(options) {\n    const { modules, level, moduleMap, moduleDepth } = options;\n    if (level >= 5) {\n        throw new Error('Possible loop in shader dependency graph');\n    }\n    // Update level on all current modules\n    for (const module of modules) {\n        moduleMap[module.name] = module;\n        if (moduleDepth[module.name] === undefined || moduleDepth[module.name] < level) {\n            moduleDepth[module.name] = level;\n        }\n    }\n    // Recurse\n    for (const module of modules) {\n        if (module.dependencies) {\n            getDependencyGraph({ modules: module.dependencies, level: level + 1, moduleMap, moduleDepth });\n        }\n    }\n}\n/**\n * Takes a list of shader module names and returns a new list of\n * shader module names that includes all dependencies, sorted so\n * that modules that are dependencies of other modules come first.\n *\n * If the shader glsl code from the returned modules is concatenated\n * in the reverse order, it is guaranteed that all functions be resolved and\n * that all function and variable definitions come before use.\n *\n * @param modules - Array of modules (inline modules or module names)\n * @return - Array of modules\n */\nexport function getShaderDependencies(modules) {\n    initializeShaderModules(modules);\n    const moduleMap = {};\n    const moduleDepth = {};\n    getDependencyGraph({ modules, level: 0, moduleMap, moduleDepth });\n    // Return a reverse sort so that dependencies come before the modules that use them\n    modules = Object.keys(moduleDepth)\n        .sort((a, b) => moduleDepth[b] - moduleDepth[a])\n        .map(name => moduleMap[name]);\n    initializeShaderModules(modules);\n    return modules;\n}\n// DEPRECATED\n/**\n * Instantiate shader modules and resolve any dependencies\n * @deprecated Use getShaderDpendencies\n */\nexport function resolveModules(modules) {\n    return getShaderDependencies(modules);\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/** Adds defines to help identify GPU architecture / platform */\nexport function getPlatformShaderDefines(platformInfo) {\n    switch (platformInfo?.gpu.toLowerCase()) {\n        case 'apple':\n            return /* glsl */ `\\\n#define APPLE_GPU\n// Apple optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n`;\n        case 'nvidia':\n            return /* glsl */ `\\\n#define NVIDIA_GPU\n// Nvidia optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n`;\n        case 'intel':\n            return /* glsl */ `\\\n#define INTEL_GPU\n// Intel optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n// Intel's built-in 'tan' function doesn't have acceptable precision\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n`;\n        case 'amd':\n            // AMD Does not eliminate fp64 code\n            return /* glsl */ `\\\n#define AMD_GPU\n`;\n        default:\n            // We don't know what GPU it is, could be that the GPU driver or\n            // browser is not implementing UNMASKED_RENDERER constant and not\n            // reporting a correct name\n            return /* glsl */ `\\\n#define DEFAULT_GPU\n// Prevent driver from optimizing away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n// Headless Chrome's software shader 'tan' function doesn't have acceptable precision\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// If the GPU doesn't have full 32 bits precision, will causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n`;\n    }\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// TRANSPILATION TABLES\n/**\n * Transpiles GLSL 3.00 shader source code to target GLSL version (3.00 or 1.00)\n *\n * @note We always run transpiler even if same version e.g. 3.00 => 3.00\n * @note For texture sampling transpilation, apps need to use non-standard texture* calls in GLSL 3.00 source\n * RFC: https://github.com/visgl/luma.gl/blob/7.0-release/dev-docs/RFCs/v6.0/portable-glsl-300-rfc.md\n */\nexport function transpileGLSLShader(source, stage) {\n    const sourceGLSLVersion = Number(source.match(/^#version[ \\t]+(\\d+)/m)?.[1] || 100);\n    if (sourceGLSLVersion !== 300) {\n        // TODO - we splurge on a longer error message to help deck.gl custom layer developers\n        throw new Error('luma.gl v9 only supports GLSL 3.00 shader sources');\n    }\n    switch (stage) {\n        case 'vertex':\n            source = convertShader(source, ES300_VERTEX_REPLACEMENTS);\n            return source;\n        case 'fragment':\n            source = convertShader(source, ES300_FRAGMENT_REPLACEMENTS);\n            return source;\n        default:\n            // Unknown shader stage\n            throw new Error(stage);\n    }\n}\n/** Simple regex replacements for GLSL ES 1.00 syntax that has changed in GLSL ES 3.00 */\nconst ES300_REPLACEMENTS = [\n    // Fix poorly formatted version directive\n    [/^(#version[ \\t]+(100|300[ \\t]+es))?[ \\t]*\\n/, '#version 300 es\\n'],\n    // The individual `texture...()` functions were replaced with `texture()` overloads\n    [/\\btexture(2D|2DProj|Cube)Lod(EXT)?\\(/g, 'textureLod('],\n    [/\\btexture(2D|2DProj|Cube)(EXT)?\\(/g, 'texture(']\n];\nconst ES300_VERTEX_REPLACEMENTS = [\n    ...ES300_REPLACEMENTS,\n    // `attribute` keyword replaced with `in`\n    [makeVariableTextRegExp('attribute'), 'in $1'],\n    // `varying` keyword replaced with `out`\n    [makeVariableTextRegExp('varying'), 'out $1']\n];\n/** Simple regex replacements for GLSL ES 1.00 syntax that has changed in GLSL ES 3.00 */\nconst ES300_FRAGMENT_REPLACEMENTS = [\n    ...ES300_REPLACEMENTS,\n    // `varying` keyword replaced with `in`\n    [makeVariableTextRegExp('varying'), 'in $1']\n];\nfunction convertShader(source, replacements) {\n    for (const [pattern, replacement] of replacements) {\n        source = source.replace(pattern, replacement);\n    }\n    return source;\n}\n/**\n * Creates a regexp that tests for a specific variable type\n * @example\n *   should match:\n *     in float weight;\n *     out vec4 positions[2];\n *   should not match:\n *     void f(out float a, in float b) {}\n */\nfunction makeVariableTextRegExp(qualifier) {\n    return new RegExp(`\\\\b${qualifier}[ \\\\t]+(\\\\w+[ \\\\t]+\\\\w+(\\\\[\\\\w+\\\\])?;)`, 'g');\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/** Generate hook source code */\nexport function getShaderHooks(hookFunctions, hookInjections) {\n    let result = '';\n    for (const hookName in hookFunctions) {\n        const hookFunction = hookFunctions[hookName];\n        result += `void ${hookFunction.signature} {\\n`;\n        if (hookFunction.header) {\n            result += `  ${hookFunction.header}`;\n        }\n        if (hookInjections[hookName]) {\n            const injections = hookInjections[hookName];\n            injections.sort((a, b) => a.order - b.order);\n            for (const injection of injections) {\n                result += `  ${injection.injection}\\n`;\n            }\n        }\n        if (hookFunction.footer) {\n            result += `  ${hookFunction.footer}`;\n        }\n        result += '}\\n';\n    }\n    return result;\n}\n/**\n * Parse string based hook functions\n * And split per shader\n */\nexport function normalizeShaderHooks(hookFunctions) {\n    const result = { vertex: {}, fragment: {} };\n    for (const hookFunction of hookFunctions) {\n        let opts;\n        let hook;\n        if (typeof hookFunction !== 'string') {\n            opts = hookFunction;\n            hook = opts.hook;\n        }\n        else {\n            opts = {};\n            hook = hookFunction;\n        }\n        hook = hook.trim();\n        const [shaderStage, signature] = hook.split(':');\n        const name = hook.replace(/\\(.+/, '');\n        const normalizedHook = Object.assign(opts, { signature });\n        switch (shaderStage) {\n            case 'vs':\n                result.vertex[name] = normalizedHook;\n                break;\n            case 'fs':\n                result.fragment[name] = normalizedHook;\n                break;\n            default:\n                throw new Error(shaderStage);\n        }\n    }\n    return result;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/** Extracts information from shader source code */\nexport function getShaderInfo(source, defaultName) {\n    return {\n        name: getShaderName(source, defaultName),\n        language: 'glsl',\n        version: getShaderVersion(source)\n    };\n}\n/** Extracts GLSLIFY style naming of shaders: `#define SHADER_NAME ...` */\nfunction getShaderName(shader, defaultName = 'unnamed') {\n    const SHADER_NAME_REGEXP = /#define[^\\S\\r\\n]*SHADER_NAME[^\\S\\r\\n]*([A-Za-z0-9_-]+)\\s*/;\n    const match = SHADER_NAME_REGEXP.exec(shader);\n    return match ? match[1] : defaultName;\n}\n/** returns GLSL shader version of given shader string */\nfunction getShaderVersion(source) {\n    let version = 100;\n    const words = source.match(/[^\\s]+/g);\n    if (words && words.length >= 2 && words[0] === '#version') {\n        const parsedVersion = parseInt(words[1], 10);\n        if (Number.isFinite(parsedVersion)) {\n            version = parsedVersion;\n        }\n    }\n    if (version !== 100 && version !== 300) {\n        throw new Error(`Invalid GLSL version ${version}`);\n    }\n    return version;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { getShaderModuleDependencies } from \"../shader-module/shader-module-dependencies.js\";\nimport { getPlatformShaderDefines } from \"./platform-defines.js\";\nimport { injectShader, DECLARATION_INJECT_MARKER } from \"./shader-injections.js\";\nimport { transpileGLSLShader } from \"../shader-transpiler/transpile-glsl-shader.js\";\nimport { checkShaderModuleDeprecations } from \"../shader-module/shader-module.js\";\nimport { normalizeShaderHooks, getShaderHooks } from \"./shader-hooks.js\";\nimport { assert } from \"../utils/assert.js\";\nimport { getShaderInfo } from \"../glsl-utils/get-shader-info.js\";\nconst INJECT_SHADER_DECLARATIONS = `\\n\\n${DECLARATION_INJECT_MARKER}\\n`;\n/**\n * Precision prologue to inject before functions are injected in shader\n * TODO - extract any existing prologue in the fragment source and move it up...\n */\nconst FRAGMENT_SHADER_PROLOGUE = /* glsl */ `\\\nprecision highp float;\n`;\n/**\n * Inject a list of shader modules into a single shader source for WGSL\n */\nexport function assembleWGSLShader(options) {\n    const modules = getShaderModuleDependencies(options.modules || []);\n    return {\n        source: assembleShaderWGSL(options.platformInfo, {\n            ...options,\n            source: options.source,\n            stage: 'vertex',\n            modules\n        }),\n        getUniforms: assembleGetUniforms(modules)\n    };\n}\n/**\n * Injects dependent shader module sources into pair of main vertex/fragment shader sources for GLSL\n */\nexport function assembleGLSLShaderPair(options) {\n    const { vs, fs } = options;\n    const modules = getShaderModuleDependencies(options.modules || []);\n    return {\n        vs: assembleShaderGLSL(options.platformInfo, {\n            ...options,\n            source: vs,\n            stage: 'vertex',\n            modules\n        }),\n        fs: assembleShaderGLSL(options.platformInfo, {\n            ...options,\n            // @ts-expect-error\n            source: fs,\n            stage: 'fragment',\n            modules\n        }),\n        getUniforms: assembleGetUniforms(modules)\n    };\n}\n/**\n * Pulls together complete source code for either a vertex or a fragment shader\n * adding prologues, requested module chunks, and any final injections.\n * @param gl\n * @param options\n * @returns\n */\nexport function assembleShaderWGSL(platformInfo, options) {\n    const { \n    // id,\n    source, stage, modules, \n    // defines = {},\n    hookFunctions = [], inject = {}, log } = options;\n    assert(typeof source === 'string', 'shader source must be a string');\n    // const isVertex = type === 'vs';\n    // const sourceLines = source.split('\\n');\n    const coreSource = source;\n    // Combine Module and Application Defines\n    // const allDefines = {};\n    // modules.forEach(module => {\n    //   Object.assign(allDefines, module.getDefines());\n    // });\n    // Object.assign(allDefines, defines);\n    // Add platform defines (use these to work around platform-specific bugs and limitations)\n    // Add common defines (GLSL version compatibility, feature detection)\n    // Add precision declaration for fragment shaders\n    let assembledSource = '';\n    //   prologue\n    //     ? `\\\n    // ${getShaderNameDefine({id, source, type})}\n    // ${getShaderType(type)}\n    // ${getPlatformShaderDefines(platformInfo)}\n    // ${getApplicationDefines(allDefines)}\n    // ${isVertex ? '' : FRAGMENT_SHADER_PROLOGUE}\n    // `\n    // `;\n    const hookFunctionMap = normalizeShaderHooks(hookFunctions);\n    // Add source of dependent modules in resolved order\n    const hookInjections = {};\n    const declInjections = {};\n    const mainInjections = {};\n    for (const key in inject) {\n        const injection = typeof inject[key] === 'string' ? { injection: inject[key], order: 0 } : inject[key];\n        const match = /^(v|f)s:(#)?([\\w-]+)$/.exec(key);\n        if (match) {\n            const hash = match[2];\n            const name = match[3];\n            if (hash) {\n                if (name === 'decl') {\n                    declInjections[key] = [injection];\n                }\n                else {\n                    mainInjections[key] = [injection];\n                }\n            }\n            else {\n                hookInjections[key] = [injection];\n            }\n        }\n        else {\n            // Regex injection\n            mainInjections[key] = [injection];\n        }\n    }\n    // TODO - hack until shadertool modules support WebGPU\n    const modulesToInject = modules;\n    for (const module of modulesToInject) {\n        if (log) {\n            checkShaderModuleDeprecations(module, coreSource, log);\n        }\n        const moduleSource = getShaderModuleSource(module, 'wgsl');\n        // Add the module source, and a #define that declares it presence\n        assembledSource += moduleSource;\n        const injections = module.injections?.[stage] || {};\n        for (const key in injections) {\n            const match = /^(v|f)s:#([\\w-]+)$/.exec(key);\n            if (match) {\n                const name = match[2];\n                const injectionType = name === 'decl' ? declInjections : mainInjections;\n                injectionType[key] = injectionType[key] || [];\n                injectionType[key].push(injections[key]);\n            }\n            else {\n                hookInjections[key] = hookInjections[key] || [];\n                hookInjections[key].push(injections[key]);\n            }\n        }\n    }\n    // For injectShader\n    assembledSource += INJECT_SHADER_DECLARATIONS;\n    assembledSource = injectShader(assembledSource, stage, declInjections);\n    assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);\n    // Add the version directive and actual source of this shader\n    assembledSource += coreSource;\n    // Apply any requested shader injections\n    assembledSource = injectShader(assembledSource, stage, mainInjections);\n    return assembledSource;\n}\n/**\n * Pulls together complete source code for either a vertex or a fragment shader\n * adding prologues, requested module chunks, and any final injections.\n * @param gl\n * @param options\n * @returns\n */\nfunction assembleShaderGLSL(platformInfo, options) {\n    const { id, source, stage, language = 'glsl', modules, defines = {}, hookFunctions = [], inject = {}, prologue = true, log } = options;\n    assert(typeof source === 'string', 'shader source must be a string');\n    const sourceVersion = language === 'glsl' ? getShaderInfo(source).version : -1;\n    const targetVersion = platformInfo.shaderLanguageVersion;\n    const sourceVersionDirective = sourceVersion === 100 ? '#version 100' : '#version 300 es';\n    const sourceLines = source.split('\\n');\n    // TODO : keep all pre-processor statements at the beginning of the shader.\n    const coreSource = sourceLines.slice(1).join('\\n');\n    // Combine Module and Application Defines\n    const allDefines = {};\n    modules.forEach(module => {\n        Object.assign(allDefines, module.defines);\n    });\n    Object.assign(allDefines, defines);\n    // Add platform defines (use these to work around platform-specific bugs and limitations)\n    // Add common defines (GLSL version compatibility, feature detection)\n    // Add precision declaration for fragment shaders\n    let assembledSource = '';\n    switch (language) {\n        case 'wgsl':\n            break;\n        case 'glsl':\n            assembledSource = prologue\n                ? `\\\n${sourceVersionDirective}\n\n// ----- PROLOGUE -------------------------\n${getShaderNameDefine({ id, source, stage })}\n${`#define SHADER_TYPE_${stage.toUpperCase()}`}\n\n${getPlatformShaderDefines(platformInfo)}\n${stage === 'fragment' ? FRAGMENT_SHADER_PROLOGUE : ''}\n\n// ----- APPLICATION DEFINES -------------------------\n\n${getApplicationDefines(allDefines)}\n\n`\n                : `${sourceVersionDirective}\n`;\n            break;\n    }\n    const hookFunctionMap = normalizeShaderHooks(hookFunctions);\n    // Add source of dependent modules in resolved order\n    const hookInjections = {};\n    const declInjections = {};\n    const mainInjections = {};\n    for (const key in inject) {\n        const injection = typeof inject[key] === 'string' ? { injection: inject[key], order: 0 } : inject[key];\n        const match = /^(v|f)s:(#)?([\\w-]+)$/.exec(key);\n        if (match) {\n            const hash = match[2];\n            const name = match[3];\n            if (hash) {\n                if (name === 'decl') {\n                    declInjections[key] = [injection];\n                }\n                else {\n                    mainInjections[key] = [injection];\n                }\n            }\n            else {\n                hookInjections[key] = [injection];\n            }\n        }\n        else {\n            // Regex injection\n            mainInjections[key] = [injection];\n        }\n    }\n    for (const module of modules) {\n        if (log) {\n            checkShaderModuleDeprecations(module, coreSource, log);\n        }\n        const moduleSource = getShaderModuleSource(module, stage);\n        // Add the module source, and a #define that declares it presence\n        assembledSource += moduleSource;\n        const injections = module.instance?.normalizedInjections[stage] || {};\n        for (const key in injections) {\n            const match = /^(v|f)s:#([\\w-]+)$/.exec(key);\n            if (match) {\n                const name = match[2];\n                const injectionType = name === 'decl' ? declInjections : mainInjections;\n                injectionType[key] = injectionType[key] || [];\n                injectionType[key].push(injections[key]);\n            }\n            else {\n                hookInjections[key] = hookInjections[key] || [];\n                hookInjections[key].push(injections[key]);\n            }\n        }\n    }\n    assembledSource += '// ----- MAIN SHADER SOURCE -------------------------';\n    // For injectShader\n    assembledSource += INJECT_SHADER_DECLARATIONS;\n    assembledSource = injectShader(assembledSource, stage, declInjections);\n    assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);\n    // Add the version directive and actual source of this shader\n    assembledSource += coreSource;\n    // Apply any requested shader injections\n    assembledSource = injectShader(assembledSource, stage, mainInjections);\n    if (language === 'glsl' && sourceVersion !== targetVersion) {\n        assembledSource = transpileGLSLShader(assembledSource, stage);\n    }\n    return assembledSource.trim();\n}\n/**\n * Returns a combined `getUniforms` covering the options for all the modules,\n * the created function will pass on options to the inidividual `getUniforms`\n * function of each shader module and combine the results into one object that\n * can be passed to setUniforms.\n * @param modules\n * @returns\n */\nexport function assembleGetUniforms(modules) {\n    return function getUniforms(opts) {\n        const uniforms = {};\n        for (const module of modules) {\n            // `modules` is already sorted by dependency level. This guarantees that\n            // modules have access to the uniforms that are generated by their dependencies.\n            const moduleUniforms = module.getUniforms?.(opts, uniforms);\n            Object.assign(uniforms, moduleUniforms);\n        }\n        return uniforms;\n    };\n}\n/**\n * Generate \"glslify-compatible\" SHADER_NAME defines\n * These are understood by the GLSL error parsing function\n * If id is provided and no SHADER_NAME constant is present in source, create one\n */\nfunction getShaderNameDefine(options) {\n    const { id, source, stage } = options;\n    const injectShaderName = id && source.indexOf('SHADER_NAME') === -1;\n    return injectShaderName\n        ? `\n#define SHADER_NAME ${id}_${stage}`\n        : '';\n}\n/** Generates application defines from an object of key value pairs */\nfunction getApplicationDefines(defines = {}) {\n    let sourceText = '';\n    for (const define in defines) {\n        const value = defines[define];\n        if (value || Number.isFinite(value)) {\n            sourceText += `#define ${define.toUpperCase()} ${defines[define]}\\n`;\n        }\n    }\n    return sourceText;\n}\n/** Extracts the source code chunk for the specified shader type from the named shader module */\nexport function getShaderModuleSource(module, stage) {\n    let moduleSource;\n    switch (stage) {\n        case 'vertex':\n            moduleSource = module.vs || '';\n            break;\n        case 'fragment':\n            moduleSource = module.fs || '';\n            break;\n        case 'wgsl':\n            moduleSource = module.source || '';\n            break;\n        default:\n            assert(false);\n    }\n    if (!module.name) {\n        throw new Error('Shader module must have a name');\n    }\n    const moduleName = module.name.toUpperCase().replace(/[^0-9a-z]/gi, '_');\n    let source = `\\\n// ----- MODULE ${module.name} ---------------\n\n`;\n    if (stage !== 'wgsl') {\n        source += `#define MODULE_${moduleName}\\n`;\n    }\n    source += `${moduleSource}\\n`;\n    return source;\n}\n/*\nfunction getHookFunctions(\n  hookFunctions: Record<string, HookFunction>,\n  hookInjections: Record<string, Injection[]>\n): string {\n  let result = '';\n  for (const hookName in hookFunctions) {\n    const hookFunction = hookFunctions[hookName];\n    result += `void ${hookFunction.signature} {\\n`;\n    if (hookFunction.header) {\n      result += `  ${hookFunction.header}`;\n    }\n    if (hookInjections[hookName]) {\n      const injections = hookInjections[hookName];\n      injections.sort((a: {order: number}, b: {order: number}): number => a.order - b.order);\n      for (const injection of injections) {\n        result += `  ${injection.injection}\\n`;\n      }\n    }\n    if (hookFunction.footer) {\n      result += `  ${hookFunction.footer}`;\n    }\n    result += '}\\n';\n  }\n\n  return result;\n}\n\nfunction normalizeHookFunctions(hookFunctions: (string | HookFunction)[]): {\n  vs: Record<string, HookFunction>;\n  fs: Record<string, HookFunction>;\n} {\n  const result: {vs: Record<string, any>; fs: Record<string, any>} = {\n    vs: {},\n    fs: {}\n  };\n\n  hookFunctions.forEach((hookFunction: string | HookFunction) => {\n    let opts: HookFunction;\n    let hook: string;\n    if (typeof hookFunction !== 'string') {\n      opts = hookFunction;\n      hook = opts.hook;\n    } else {\n      opts = {} as HookFunction;\n      hook = hookFunction;\n    }\n    hook = hook.trim();\n    const [stage, signature] = hook.split(':');\n    const name = hook.replace(/\\(.+/, '');\n    if (stage !== 'vs' && stage !== 'fs') {\n      throw new Error(stage);\n    }\n    result[stage][name] = Object.assign(opts, {signature});\n  });\n\n  return result;\n}\n*/\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst IFDEF_REGEXP = /^\\s*\\#\\s*ifdef\\s*([a-zA-Z_]+)\\s*$/;\nconst ENDIF_REGEXP = /^\\s*\\#\\s*endif\\s*$/;\nexport function preprocess(source, options) {\n    const lines = source.split('\\n');\n    const output = [];\n    let conditional = true;\n    let currentDefine = null;\n    for (const line of lines) {\n        const matchIf = line.match(IFDEF_REGEXP);\n        const matchEnd = line.match(ENDIF_REGEXP);\n        if (matchIf) {\n            currentDefine = matchIf[1];\n            conditional = Boolean(options?.defines?.[currentDefine]);\n        }\n        else if (matchEnd) {\n            conditional = true;\n        }\n        else if (conditional) {\n            output.push(line);\n        }\n    }\n    return output.join('\\n');\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { initializeShaderModules } from \"./shader-module/shader-module.js\";\nimport { assembleWGSLShader, assembleGLSLShaderPair } from \"./shader-assembly/assemble-shaders.js\";\nimport { preprocess } from \"./preprocessor/preprocessor.js\";\n/**\n * A stateful version of `assembleShaders` that can be used to assemble shaders.\n * Supports setting of default modules and hooks.\n */\nexport class ShaderAssembler {\n    /** Default ShaderAssembler instance */\n    static defaultShaderAssembler;\n    /** Hook functions */\n    _hookFunctions = [];\n    /** Shader modules */\n    _defaultModules = [];\n    /**\n     * A default shader assembler instance - the natural place to register default modules and hooks\n     * @returns\n     */\n    static getDefaultShaderAssembler() {\n        ShaderAssembler.defaultShaderAssembler =\n            ShaderAssembler.defaultShaderAssembler || new ShaderAssembler();\n        return ShaderAssembler.defaultShaderAssembler;\n    }\n    /**\n     * Add a default module that does not have to be provided with every call to assembleShaders()\n     */\n    addDefaultModule(module) {\n        if (!this._defaultModules.find(m => m.name === (typeof module === 'string' ? module : module.name))) {\n            this._defaultModules.push(module);\n        }\n    }\n    /**\n     * Remove a default module\n     */\n    removeDefaultModule(module) {\n        const moduleName = typeof module === 'string' ? module : module.name;\n        this._defaultModules = this._defaultModules.filter(m => m.name !== moduleName);\n    }\n    /**\n     * Register a shader hook\n     * @param hook\n     * @param opts\n     */\n    addShaderHook(hook, opts) {\n        if (opts) {\n            hook = Object.assign(opts, { hook });\n        }\n        this._hookFunctions.push(hook);\n    }\n    /**\n     * Assemble a WGSL unified shader\n     * @param platformInfo\n     * @param props\n     * @returns\n     */\n    assembleWGSLShader(props) {\n        const modules = this._getModuleList(props.modules); // Combine with default modules\n        const hookFunctions = this._hookFunctions; // TODO - combine with default hook functions\n        const { source, getUniforms } = assembleWGSLShader({\n            ...props,\n            // @ts-expect-error\n            source: props.source,\n            modules,\n            hookFunctions\n        });\n        // WGSL does not have built-in preprocessing support (just compile time constants)\n        const preprocessedSource = props.platformInfo.shaderLanguage === 'wgsl' ? preprocess(source) : source;\n        return { source: preprocessedSource, getUniforms, modules };\n    }\n    /**\n     * Assemble a pair of shaders into a single shader program\n     * @param platformInfo\n     * @param props\n     * @returns\n     */\n    assembleGLSLShaderPair(props) {\n        const modules = this._getModuleList(props.modules); // Combine with default modules\n        const hookFunctions = this._hookFunctions; // TODO - combine with default hook functions\n        const assembled = assembleGLSLShaderPair({\n            ...props,\n            // @ts-expect-error\n            vs: props.vs,\n            // @ts-expect-error\n            fs: props.fs,\n            modules,\n            hookFunctions\n        });\n        return { ...assembled, modules };\n    }\n    /**\n     * Dedupe and combine with default modules\n     */\n    _getModuleList(appModules = []) {\n        const modules = new Array(this._defaultModules.length + appModules.length);\n        const seen = {};\n        let count = 0;\n        for (let i = 0, len = this._defaultModules.length; i < len; ++i) {\n            const module = this._defaultModules[i];\n            const name = module.name;\n            modules[count++] = module;\n            seen[name] = true;\n        }\n        for (let i = 0, len = appModules.length; i < len; ++i) {\n            const module = appModules[i];\n            const name = module.name;\n            if (!seen[name]) {\n                modules[count++] = module;\n                seen[name] = true;\n            }\n        }\n        modules.length = count;\n        initializeShaderModules(modules);\n        return modules;\n    }\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst FS_GLES = /* glsl */ `\\\nout vec4 transform_output;\nvoid main() {\n  transform_output = vec4(0);\n}`;\nconst FS300 = `#version 300 es\\n${FS_GLES}`;\n// Prase given glsl line and return qualifier details or null\nexport function getQualifierDetails(line, qualifiers) {\n    qualifiers = Array.isArray(qualifiers) ? qualifiers : [qualifiers];\n    const words = line.replace(/^\\s+/, '').split(/\\s+/);\n    // TODO add support for precession qualifiers (highp, mediump and lowp)\n    const [qualifier, type, definition] = words;\n    if (!qualifiers.includes(qualifier) || !type || !definition) {\n        return null;\n    }\n    const name = definition.split(';')[0];\n    return { qualifier, type, name };\n}\n/**\n * Given the shader input and output variable names,\n * builds and return a pass through fragment shader.\n */\nexport function getPassthroughFS(options) {\n    const { input, inputChannels, output } = options || {};\n    if (!input) {\n        // Default shader\n        return FS300;\n    }\n    if (!inputChannels) {\n        throw new Error('inputChannels');\n    }\n    const inputType = channelCountToType(inputChannels);\n    const outputValue = convertToVec4(input, inputChannels);\n    return `\\\n#version 300 es\nin ${inputType} ${input};\nout vec4 ${output};\nvoid main() {\n  ${output} = ${outputValue};\n}`;\n}\n/** convert glsl type to suffix */\nexport function typeToChannelSuffix(type) {\n    // prettier-ignore\n    switch (type) {\n        case 'float': return 'x';\n        case 'vec2': return 'xy';\n        case 'vec3': return 'xyz';\n        case 'vec4': return 'xyzw';\n        default:\n            throw new Error(type);\n    }\n}\n/** convert glsl type to channel count */\nexport function typeToChannelCount(type) {\n    // prettier-ignore\n    switch (type) {\n        case 'float': return 1;\n        case 'vec2': return 2;\n        case 'vec3': return 3;\n        case 'vec4': return 4;\n        default:\n            throw new Error(type);\n    }\n}\nfunction channelCountToType(channels) {\n    // prettier-ignore\n    switch (channels) {\n        case 1: return 'float';\n        case 2: return 'vec2';\n        case 3: return 'vec3';\n        case 4: return 'vec4';\n        default:\n            throw new Error(`invalid channels: ${channels}`);\n    }\n}\n/** Returns glsl instruction for converting to vec4 */\nexport function convertToVec4(variable, channels) {\n    // prettier-ignore\n    switch (channels) {\n        case 1: return `vec4(${variable}, 0.0, 0.0, 1.0)`;\n        case 2: return `vec4(${variable}, 0.0, 1.0)`;\n        case 3: return `vec4(${variable}, 1.0)`;\n        case 4: return variable;\n        default:\n            throw new Error(`invalid channels: ${channels}`);\n    }\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/**\n * Capitalize first letter of a string\n * @param {string} str\n * @returns {string}\n */\nexport function capitalize(str) {\n    return typeof str === 'string' ? str.charAt(0).toUpperCase() + str.slice(1) : str;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { capitalize } from \"../utils/capitalize.js\";\nexport function generateGLSLForModule(module, options) {\n    return generateGLSLUniformDeclarations(module, options);\n}\nfunction generateGLSLUniformDeclarations(module, options) {\n    const glsl = [];\n    // => uniform UniformBlockName {\n    switch (options.uniforms) {\n        case 'scoped-interface-blocks':\n        case 'unscoped-interface-blocks':\n            glsl.push(`uniform ${capitalize(module.name)} {`);\n            break;\n        case 'uniforms':\n        // ignore\n    }\n    for (const [uniformName, uniformFormat] of Object.entries(module.uniformTypes || {})) {\n        const glslUniformType = getGLSLUniformType(uniformFormat);\n        switch (options.uniforms) {\n            case 'scoped-interface-blocks':\n                // => uniform UniformBlockName {\n                glsl.push(`  ${glslUniformType} ${uniformName};`);\n                break;\n            case 'unscoped-interface-blocks':\n                // => uniform UniformBlockName {\n                glsl.push(`  ${glslUniformType} ${module.name}_${uniformName};`);\n                break;\n            case 'uniforms':\n                glsl.push(`uniform ${glslUniformType} ${module.name}_${uniformName};`);\n        }\n    }\n    switch (options.uniforms) {\n        case 'scoped-interface-blocks':\n            glsl.push(`} ${module.name};`);\n            break;\n        case 'unscoped-interface-blocks':\n            glsl.push('};');\n            break;\n        case 'uniforms':\n        // ignore\n    }\n    // final new line\n    glsl.push('');\n    return glsl.join('\\n');\n}\n/** Map a luma.gl WebGPU style uniform type to GLSL */\nfunction getGLSLUniformType(uniformFormat) {\n    const UNIFORM_TYPE_TO_GLSL = {\n        f32: 'float',\n        i32: 'int',\n        u32: 'uint',\n        'vec2<f32>': 'vec2',\n        'vec3<f32>': 'vec3',\n        'vec4<f32>': 'vec4',\n        'vec2<i32>': 'ivec2',\n        'vec3<i32>': 'ivec3',\n        'vec4<i32>': 'ivec4',\n        'vec2<u32>': 'uvec2',\n        'vec3<u32>': 'uvec3',\n        'vec4<u32>': 'uvec4',\n        'mat2x2<f32>': 'mat2',\n        'mat2x3<f32>': 'mat2x3',\n        'mat2x4<f32>': 'mat2x4',\n        'mat3x2<f32>': 'mat3x2',\n        'mat3x3<f32>': 'mat3',\n        'mat3x4<f32>': 'mat3x4',\n        'mat4x2<f32>': 'mat4x2',\n        'mat4x3<f32>': 'mat4x3',\n        'mat4x4<f32>': 'mat4'\n    };\n    const glsl = UNIFORM_TYPE_TO_GLSL[uniformFormat];\n    return glsl;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { capitalize } from \"../utils/capitalize.js\";\nexport function generateWGSLForModule(module, options) {\n    return generateWGSLUniformDeclarations(module, options);\n}\nexport function generateWGSLUniformDeclarations(module, options) {\n    const wgsl = [];\n    // => uniform UniformBlockName {\n    wgsl.push(`struct ${capitalize(module.name)} {`);\n    for (const [uniformName, uniformFormat] of Object.entries(module?.uniformTypes || {})) {\n        const wgslUniformType = uniformFormat;\n        wgsl.push(`  ${uniformName} : ${wgslUniformType};`);\n    }\n    wgsl.push('};');\n    wgsl.push(`var<uniform> ${module.name} : ${capitalize(module.name)};`);\n    return wgsl.join('\\n');\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { generateGLSLForModule } from \"./glsl/generate-glsl.js\";\nimport { generateWGSLForModule } from \"./wgsl/generate-wgsl.js\";\n/** Generates shader code for a module */\nexport function generateShaderForModule(module, options) {\n    switch (options.shaderLanguage) {\n        case 'glsl':\n            return generateGLSLForModule(module, options);\n        case 'wgsl':\n            return generateWGSLForModule(module, options);\n    }\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { log } from '@luma.gl/core';\nimport { WgslReflect } from 'wgsl_reflect';\n/**\n * Parse a ShaderLayout from WGSL shader source code.\n * @param source WGSL source code (can contain both @vertex and @fragment entry points)\n * @returns\n */\nexport function getShaderLayoutFromWGSL(source) {\n    const shaderLayout = { attributes: [], bindings: [] };\n    let parsedWGSL;\n    try {\n        parsedWGSL = parseWGSL(source);\n    }\n    catch (error) {\n        log.error(error.message)();\n        return shaderLayout;\n    }\n    for (const uniform of parsedWGSL.uniforms) {\n        const members = [];\n        for (const attribute of uniform.type?.members || []) {\n            members.push({\n                name: attribute.name,\n                type: getType(attribute.type)\n            });\n        }\n        shaderLayout.bindings.push({\n            type: 'uniform',\n            name: uniform.name,\n            location: uniform.binding,\n            // @ts-expect-error\n            group: uniform.group,\n            members\n        });\n    }\n    const vertex = parsedWGSL.entry.vertex[0]; // \"main\"\n    // Vertex shader inputs\n    const attributeCount = vertex?.inputs.length || 0; // inputs to \"main\"\n    for (let i = 0; i < attributeCount; i++) {\n        const wgslAttribute = vertex.inputs[i];\n        // locationType can be \"builtin\"\n        if (wgslAttribute.locationType === 'location') {\n            const type = getType(wgslAttribute.type);\n            shaderLayout.attributes.push({\n                name: wgslAttribute.name,\n                location: Number(wgslAttribute.location),\n                type\n            });\n        }\n    }\n    return shaderLayout;\n}\n/** Get a valid shader attribute type string from a wgsl-reflect type */\nfunction getType(type) {\n    return type.format ? `${type.name}<${type.format.name}>` : type.name;\n}\nfunction parseWGSL(source) {\n    try {\n        return new WgslReflect(source);\n    }\n    catch (error) {\n        if (error instanceof Error) {\n            throw error;\n        }\n        let message = 'WGSL parse error';\n        if (typeof error === 'object' && error?.message) {\n            message += `: ${error.message} `;\n        }\n        if (typeof error === 'object' && error?.token) {\n            message += error.token.line || '';\n        }\n        throw new Error(message, { cause: error });\n    }\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// Forked from THREE.js under MIT license\n// Fast Half Float Conversions, http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf\nimport { clamp } from '@math.gl/core';\n/**  */\nlet float16Tables = null;\n/** Storage that can be viewed both as float and integer */\nconst buffer = new ArrayBuffer(4);\nconst floatView = new Float32Array(buffer);\nconst uint32View = new Uint32Array(buffer);\n/**\n * float32 to float16\n * @param val\n * @returns\n */\nexport function toHalfFloat(val) {\n    float16Tables ||= generateFloat16Tables();\n    // if ( Math.abs( val ) > 65504 ) console.warn( 'toHalfFloat(): Value out of range.' );\n    val = clamp(val, -65504, 65504);\n    floatView[0] = val;\n    const f = uint32View[0];\n    const e = (f >> 23) & 0x1ff;\n    return float16Tables.baseTable[e] + ((f & 0x007fffff) >> float16Tables.shiftTable[e]);\n}\n/**\n * float16 to float32\n * @param val\n * @returns\n */\nexport function fromHalfFloat(val) {\n    float16Tables ||= generateFloat16Tables();\n    const m = val >> 10;\n    uint32View[0] =\n        float16Tables.mantissaTable[float16Tables.offsetTable[m] + (val & 0x3ff)] +\n            float16Tables.exponentTable[m];\n    return floatView[0];\n}\nfunction generateFloat16Tables() {\n    // float32 to float16 helpers\n    const baseTable = new Uint32Array(512);\n    const shiftTable = new Uint32Array(512);\n    for (let i = 0; i < 256; ++i) {\n        const e = i - 127;\n        // very small number (0, -0)\n        if (e < -27) {\n            baseTable[i] = 0x0000;\n            baseTable[i | 0x100] = 0x8000;\n            shiftTable[i] = 24;\n            shiftTable[i | 0x100] = 24;\n            // small number (denorm)\n        }\n        else if (e < -14) {\n            baseTable[i] = 0x0400 >> (-e - 14);\n            baseTable[i | 0x100] = (0x0400 >> (-e - 14)) | 0x8000;\n            shiftTable[i] = -e - 1;\n            shiftTable[i | 0x100] = -e - 1;\n            // normal number\n        }\n        else if (e <= 15) {\n            baseTable[i] = (e + 15) << 10;\n            baseTable[i | 0x100] = ((e + 15) << 10) | 0x8000;\n            shiftTable[i] = 13;\n            shiftTable[i | 0x100] = 13;\n            // large number (Infinity, -Infinity)\n        }\n        else if (e < 128) {\n            baseTable[i] = 0x7c00;\n            baseTable[i | 0x100] = 0xfc00;\n            shiftTable[i] = 24;\n            shiftTable[i | 0x100] = 24;\n            // stay (NaN, Infinity, -Infinity)\n        }\n        else {\n            baseTable[i] = 0x7c00;\n            baseTable[i | 0x100] = 0xfc00;\n            shiftTable[i] = 13;\n            shiftTable[i | 0x100] = 13;\n        }\n    }\n    // float16 to float32 helpers\n    const mantissaTable = new Uint32Array(2048);\n    const exponentTable = new Uint32Array(64);\n    const offsetTable = new Uint32Array(64);\n    for (let i = 1; i < 1024; ++i) {\n        let m = i << 13; // zero pad mantissa bits\n        let e = 0; // zero exponent\n        // normalized\n        while ((m & 0x00800000) === 0) {\n            m <<= 1;\n            e -= 0x00800000; // decrement exponent\n        }\n        m &= ~0x00800000; // clear leading 1 bit\n        e += 0x38800000; // adjust bias\n        mantissaTable[i] = m | e;\n    }\n    for (let i = 1024; i < 2048; ++i) {\n        mantissaTable[i] = 0x38000000 + ((i - 1024) << 13);\n    }\n    for (let i = 1; i < 31; ++i) {\n        exponentTable[i] = i << 23;\n    }\n    exponentTable[31] = 0x47800000;\n    exponentTable[32] = 0x80000000;\n    for (let i = 33; i < 63; ++i) {\n        exponentTable[i] = 0x80000000 + ((i - 32) << 23);\n    }\n    exponentTable[63] = 0xc7800000;\n    for (let i = 1; i < 64; ++i) {\n        if (i !== 32) {\n            offsetTable[i] = 1024;\n        }\n    }\n    return { baseTable, shiftTable, mantissaTable, exponentTable, offsetTable };\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/**\n * Calculate WebGL 64 bit float\n * @param a  - the input float number\n * @param out - the output array. If not supplied, a new array is created.\n * @param startIndex - the index in the output array to fill from. Default 0.\n * @returns - the fp64 representation of the input number\n */\nexport function fp64ify(a, out = [], startIndex = 0) {\n    const hiPart = Math.fround(a);\n    const loPart = a - hiPart;\n    out[startIndex] = hiPart;\n    out[startIndex + 1] = loPart;\n    return out;\n}\n/**\n * Calculate the low part of a WebGL 64 bit float\n * @param a the input float number\n * @returns the lower 32 bit of the number\n */\nexport function fp64LowPart(a) {\n    return a - Math.fround(a);\n}\n/**\n * Calculate WebGL 64 bit matrix (transposed \"Float64Array\")\n * @param matrix  the input matrix\n * @returns the fp64 representation of the input matrix\n */\nexport function fp64ifyMatrix4(matrix) {\n    // Transpose the projection matrix to column major for GLSL.\n    const matrixFP64 = new Float32Array(32);\n    for (let i = 0; i < 4; ++i) {\n        for (let j = 0; j < 4; ++j) {\n            const index = i * 4 + j;\n            fp64ify(matrix[j * 4 + i], matrixFP64, index * 2);\n        }\n    }\n    return matrixFP64;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nfloat random(vec3 scale, float seed) {\n  /* use the fragment position for a different seed per-pixel */\n  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n}\n`;\n/** Quick random generator for fragment shaders */\nexport const random = {\n    name: 'random',\n    fs\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// import {ShaderModule} from '../../types';\nconst fp32shader = /* glsl */ `\\\n#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND\n\n// All these functions are for substituting tan() function from Intel GPU only\nconst float TWO_PI = 6.2831854820251465;\nconst float PI_2 = 1.5707963705062866;\nconst float PI_16 = 0.1963495463132858;\n\nconst float SIN_TABLE_0 = 0.19509032368659973;\nconst float SIN_TABLE_1 = 0.3826834261417389;\nconst float SIN_TABLE_2 = 0.5555702447891235;\nconst float SIN_TABLE_3 = 0.7071067690849304;\n\nconst float COS_TABLE_0 = 0.9807852506637573;\nconst float COS_TABLE_1 = 0.9238795042037964;\nconst float COS_TABLE_2 = 0.8314695954322815;\nconst float COS_TABLE_3 = 0.7071067690849304;\n\nconst float INVERSE_FACTORIAL_3 = 1.666666716337204e-01; // 1/3!\nconst float INVERSE_FACTORIAL_5 = 8.333333767950535e-03; // 1/5!\nconst float INVERSE_FACTORIAL_7 = 1.9841270113829523e-04; // 1/7!\nconst float INVERSE_FACTORIAL_9 = 2.75573188446287533e-06; // 1/9!\n\nfloat sin_taylor_fp32(float a) {\n  float r, s, t, x;\n\n  if (a == 0.0) {\n    return 0.0;\n  }\n\n  x = -a * a;\n  s = a;\n  r = a;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_3;\n  s = s + t;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_5;\n  s = s + t;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_7;\n  s = s + t;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_9;\n  s = s + t;\n\n  return s;\n}\n\nvoid sincos_taylor_fp32(float a, out float sin_t, out float cos_t) {\n  if (a == 0.0) {\n    sin_t = 0.0;\n    cos_t = 1.0;\n  }\n  sin_t = sin_taylor_fp32(a);\n  cos_t = sqrt(1.0 - sin_t * sin_t);\n}\n\nfloat tan_taylor_fp32(float a) {\n    float sin_a;\n    float cos_a;\n\n    if (a == 0.0) {\n        return 0.0;\n    }\n\n    // 2pi range reduction\n    float z = floor(a / TWO_PI);\n    float r = a - TWO_PI * z;\n\n    float t;\n    float q = floor(r / PI_2 + 0.5);\n    int j = int(q);\n\n    if (j < -2 || j > 2) {\n        return 1.0 / 0.0;\n    }\n\n    t = r - PI_2 * q;\n\n    q = floor(t / PI_16 + 0.5);\n    int k = int(q);\n    int abs_k = int(abs(float(k)));\n\n    if (abs_k > 4) {\n        return 1.0 / 0.0;\n    } else {\n        t = t - PI_16 * q;\n    }\n\n    float u = 0.0;\n    float v = 0.0;\n\n    float sin_t, cos_t;\n    float s, c;\n    sincos_taylor_fp32(t, sin_t, cos_t);\n\n    if (k == 0) {\n        s = sin_t;\n        c = cos_t;\n    } else {\n        if (abs(float(abs_k) - 1.0) < 0.5) {\n            u = COS_TABLE_0;\n            v = SIN_TABLE_0;\n        } else if (abs(float(abs_k) - 2.0) < 0.5) {\n            u = COS_TABLE_1;\n            v = SIN_TABLE_1;\n        } else if (abs(float(abs_k) - 3.0) < 0.5) {\n            u = COS_TABLE_2;\n            v = SIN_TABLE_2;\n        } else if (abs(float(abs_k) - 4.0) < 0.5) {\n            u = COS_TABLE_3;\n            v = SIN_TABLE_3;\n        }\n        if (k > 0) {\n            s = u * sin_t + v * cos_t;\n            c = u * cos_t - v * sin_t;\n        } else {\n            s = u * sin_t - v * cos_t;\n            c = u * cos_t + v * sin_t;\n        }\n    }\n\n    if (j == 0) {\n        sin_a = s;\n        cos_a = c;\n    } else if (j == 1) {\n        sin_a = c;\n        cos_a = -s;\n    } else if (j == -1) {\n        sin_a = -c;\n        cos_a = s;\n    } else {\n        sin_a = -s;\n        cos_a = -c;\n    }\n    return sin_a / cos_a;\n}\n#endif\n\nfloat tan_fp32(float a) {\n#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND\n  return tan_taylor_fp32(a);\n#else\n  return tan(a);\n#endif\n}\n`;\n/**\n * 32 bit math library (fixups for GPUs)\n */\nexport const fp32 = {\n    name: 'fp32',\n    vs: fp32shader\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// cyan color\nconst DEFAULT_HIGHLIGHT_COLOR = new Float32Array([0, 1, 1, 1]);\nconst vs = /* glsl */ `\\\nuniform pickingUniforms {\n  float isActive;\n  float isAttribute;\n  float isHighlightActive;\n  float useFloatColors;\n  vec3 highlightedObjectColor;\n  vec4 highlightColor;\n} picking;\n\nout vec4 picking_vRGBcolor_Avalid;\n\n// Normalize unsigned byte color to 0-1 range\nvec3 picking_normalizeColor(vec3 color) {\n  return picking.useFloatColors > 0.5 ? color : color / 255.0;\n}\n\n// Normalize unsigned byte color to 0-1 range\nvec4 picking_normalizeColor(vec4 color) {\n  return picking.useFloatColors > 0.5 ? color : color / 255.0;\n}\n\nbool picking_isColorZero(vec3 color) {\n  return dot(color, vec3(1.0)) < 0.00001;\n}\n\nbool picking_isColorValid(vec3 color) {\n  return dot(color, vec3(1.0)) > 0.00001;\n}\n\n// Check if this vertex is highlighted \nbool isVertexHighlighted(vec3 vertexColor) {\n  vec3 highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);\n  return\n    bool(picking.isHighlightActive) && picking_isColorZero(abs(vertexColor - highlightedObjectColor));\n}\n\n// Set the current picking color\nvoid picking_setPickingColor(vec3 pickingColor) {\n  pickingColor = picking_normalizeColor(pickingColor);\n\n  if (bool(picking.isActive)) {\n    // Use alpha as the validity flag. If pickingColor is [0, 0, 0] fragment is non-pickable\n    picking_vRGBcolor_Avalid.a = float(picking_isColorValid(pickingColor));\n\n    if (!bool(picking.isAttribute)) {\n      // Stores the picking color so that the fragment shader can render it during picking\n      picking_vRGBcolor_Avalid.rgb = pickingColor;\n    }\n  } else {\n    // Do the comparison with selected item color in vertex shader as it should mean fewer compares\n    picking_vRGBcolor_Avalid.a = float(isVertexHighlighted(pickingColor));\n  }\n}\n\nvoid picking_setPickingAttribute(float value) {\n  if (bool(picking.isAttribute)) {\n    picking_vRGBcolor_Avalid.r = value;\n  }\n}\n\nvoid picking_setPickingAttribute(vec2 value) {\n  if (bool(picking.isAttribute)) {\n    picking_vRGBcolor_Avalid.rg = value;\n  }\n}\n\nvoid picking_setPickingAttribute(vec3 value) {\n  if (bool(picking.isAttribute)) {\n    picking_vRGBcolor_Avalid.rgb = value;\n  }\n}\n`;\nconst fs = /* glsl */ `\\\nuniform pickingUniforms {\n  float isActive;\n  float isAttribute;\n  float isHighlightActive;\n  float useFloatColors;\n  vec3 highlightedObjectColor;\n  vec4 highlightColor;\n} picking;\n\nin vec4 picking_vRGBcolor_Avalid;\n\n/*\n * Returns highlight color if this item is selected.\n */\nvec4 picking_filterHighlightColor(vec4 color) {\n  // If we are still picking, we don't highlight\n  if (picking.isActive > 0.5) {\n    return color;\n  }\n\n  bool selected = bool(picking_vRGBcolor_Avalid.a);\n\n  if (selected) {\n    // Blend in highlight color based on its alpha value\n    float highLightAlpha = picking.highlightColor.a;\n    float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);\n    float highLightRatio = highLightAlpha / blendedAlpha;\n\n    vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);\n    return vec4(blendedRGB, blendedAlpha);\n  } else {\n    return color;\n  }\n}\n\n/*\n * Returns picking color if picking enabled else unmodified argument.\n */\nvec4 picking_filterPickingColor(vec4 color) {\n  if (bool(picking.isActive)) {\n    if (picking_vRGBcolor_Avalid.a == 0.0) {\n      discard;\n    }\n    return picking_vRGBcolor_Avalid;\n  }\n  return color;\n}\n\n/*\n * Returns picking color if picking is enabled if not\n * highlight color if this item is selected, otherwise unmodified argument.\n */\nvec4 picking_filterColor(vec4 color) {\n  vec4 highlightColor = picking_filterHighlightColor(color);\n  return picking_filterPickingColor(highlightColor);\n}\n`;\n/**\n * Provides support for color-coding-based picking and highlighting.\n * In particular, supports picking a specific instance in an instanced\n * draw call and highlighting an instance based on its picking color,\n * and correspondingly, supports picking and highlighting groups of\n * primitives with the same picking color in non-instanced draw-calls\n */\nexport const picking = {\n    props: {},\n    uniforms: {},\n    name: 'picking',\n    uniformTypes: {\n        isActive: 'f32',\n        isAttribute: 'f32',\n        isHighlightActive: 'f32',\n        useFloatColors: 'f32',\n        highlightedObjectColor: 'vec3<f32>',\n        highlightColor: 'vec4<f32>'\n    },\n    defaultUniforms: {\n        isActive: false,\n        isAttribute: false,\n        isHighlightActive: false,\n        useFloatColors: true,\n        highlightedObjectColor: new Float32Array([0, 0, 0]),\n        highlightColor: DEFAULT_HIGHLIGHT_COLOR\n    },\n    vs,\n    fs,\n    getUniforms\n};\nfunction getUniforms(opts = {}, prevUniforms) {\n    const uniforms = {};\n    if (opts.highlightedObjectColor === undefined) {\n        // Unless highlightedObjectColor explicitly null or set, do not update state\n    }\n    else if (opts.highlightedObjectColor === null) {\n        uniforms.isHighlightActive = false;\n    }\n    else {\n        uniforms.isHighlightActive = true;\n        const highlightedObjectColor = opts.highlightedObjectColor.slice(0, 3);\n        uniforms.highlightedObjectColor = highlightedObjectColor;\n    }\n    if (opts.highlightColor) {\n        const color = Array.from(opts.highlightColor, x => x / 255);\n        if (!Number.isFinite(color[3])) {\n            color[3] = 1;\n        }\n        uniforms.highlightColor = color;\n    }\n    if (opts.isActive !== undefined) {\n        uniforms.isActive = Boolean(opts.isActive);\n        uniforms.isAttribute = Boolean(opts.isAttribute);\n    }\n    if (opts.useFloatColors !== undefined) {\n        uniforms.useFloatColors = Boolean(opts.useFloatColors);\n    }\n    return uniforms;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const lightingUniformsGLSL = /* glsl */ `\\\nprecision highp int;\n\n// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))\nstruct AmbientLight {\n  vec3 color;\n};\n\nstruct PointLight {\n  vec3 color;\n  vec3 position;\n  vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential\n};\n\nstruct DirectionalLight {\n  vec3 color;\n  vec3 direction;\n};\n\nuniform lightingUniforms {\n  int enabled;\n  int pointLightCount;\n  int directionalLightCount;\n\n  vec3 ambientColor;\n\n  int lightType;\n  vec3 lightColor;\n  vec3 lightDirection;\n  vec3 lightPosition;\n  vec3 lightAttenuation;\n\n  // AmbientLight ambientLight;\n  // PointLight pointLight[MAX_LIGHTS];\n  // DirectionalLight directionalLight[MAX_LIGHTS];\n} lighting;\n\nPointLight lighting_getPointLight(int index) {\n  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);\n}\n\nDirectionalLight lighting_getDirectionalLight(int index) {\n  return DirectionalLight(lighting.lightColor, lighting.lightDirection);\n} \n\nfloat getPointLightAttenuation(PointLight pointLight, float distance) {\n  return pointLight.attenuation.x\n       + pointLight.attenuation.y * distance\n       + pointLight.attenuation.z * distance * distance;\n}\n\n// #endif\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const lightingUniformsWGSL = /* wgsl */ `\\\n// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))\nstruct AmbientLight {\n  color: vec3<f32>,\n};\n\nstruct PointLight {\n  color: vec3<f32>,\n  position: vec3<f32>,\n  attenuation: vec3<f32>, // 2nd order x:Constant-y:Linear-z:Exponential\n};\n\nstruct DirectionalLight {\n  color: vec3<f32>,\n  direction: vec3<f32>,\n};\n\nstruct lightingUniforms {\n  enabled: i32,\n  poightCount: i32,\n  directionalLightCount: i32,\n\n  ambientColor: vec3<f32>,\n\n  // TODO - support multiple lights by uncommenting arrays below\n  lightType: i32,\n  lightColor: vec3<f32>,\n  lightDirection: vec3<f32>,\n  lightPosition: vec3<f32>,\n  lightAttenuation: vec3<f32>,\n\n  // AmbientLight ambientLight;\n  // PointLight pointLight[MAX_LIGHTS];\n  // DirectionalLight directionalLight[MAX_LIGHTS];\n};\n\n// Binding 0:1 is reserved for lighting (Note: could go into separate bind group as it is stable across draw calls)\n@binding(1) @group(0) var<uniform> lighting : lightingUniforms;\n\nfn lighting_getPointLight(index: i32) -> PointLight {\n  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);\n}\n\nfn lighting_getDirectionalLight(index: i32) -> DirectionalLight {\n  return DirectionalLight(lighting.lightColor, lighting.lightDirection);\n} \n\nfn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {\n  return pointLight.attenuation.x\n       + pointLight.attenuation.y * distance\n       + pointLight.attenuation.z * distance * distance;\n}\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { lightingUniformsGLSL } from \"./lighting-uniforms-glsl.js\";\nimport { lightingUniformsWGSL } from \"./lighting-uniforms-wgsl.js\";\n/** Max number of supported lights (in addition to ambient light */\nconst MAX_LIGHTS = 5;\n/** Whether to divide */\nconst COLOR_FACTOR = 255.0;\n/** Shader type field for lights */\nexport var LIGHT_TYPE;\n(function (LIGHT_TYPE) {\n    LIGHT_TYPE[LIGHT_TYPE[\"POINT\"] = 0] = \"POINT\";\n    LIGHT_TYPE[LIGHT_TYPE[\"DIRECTIONAL\"] = 1] = \"DIRECTIONAL\";\n})(LIGHT_TYPE || (LIGHT_TYPE = {}));\n/** UBO ready lighting module */\nexport const lighting = {\n    props: {},\n    uniforms: {},\n    name: 'lighting',\n    defines: {\n        MAX_LIGHTS\n    },\n    uniformTypes: {\n        enabled: 'i32',\n        ambientLightColor: 'vec3<f32>',\n        numberOfLights: 'i32', // , array: MAX_LIGHTS,\n        lightType: 'i32', // , array: MAX_LIGHTS,\n        lightColor: 'vec3<f32>', // , array: MAX_LIGHTS,\n        lightPosition: 'vec3<f32>', // , array: MAX_LIGHTS,\n        // TODO - could combine direction and attenuation\n        lightDirection: 'vec3<f32>', // , array: MAX_LIGHTS,\n        lightAttenuation: 'vec3<f32>' // , array: MAX_LIGHTS},\n    },\n    defaultUniforms: {\n        enabled: 1,\n        ambientLightColor: [0.1, 0.1, 0.1],\n        numberOfLights: 0,\n        lightType: LIGHT_TYPE.POINT,\n        lightColor: [1, 1, 1],\n        lightPosition: [1, 1, 2],\n        // TODO - could combine direction and attenuation\n        lightDirection: [1, 1, 1],\n        lightAttenuation: [1, 1, 1]\n    },\n    source: lightingUniformsWGSL,\n    vs: lightingUniformsGLSL,\n    fs: lightingUniformsGLSL,\n    getUniforms\n};\nfunction getUniforms(props, prevUniforms = {}) {\n    // Copy props so we can modify\n    props = props ? { ...props } : props;\n    // TODO legacy\n    if (!props) {\n        return { ...lighting.defaultUniforms };\n    }\n    // Support for array of lights. Type of light is detected by type field\n    if (props.lights) {\n        props = { ...props, ...extractLightTypes(props.lights), lights: undefined };\n    }\n    // Specify lights separately\n    const { ambientLight, pointLights, directionalLights } = props || {};\n    const hasLights = ambientLight ||\n        (pointLights && pointLights.length > 0) ||\n        (directionalLights && directionalLights.length > 0);\n    // TODO - this may not be the correct decision\n    if (!hasLights) {\n        return { ...lighting.defaultUniforms, enabled: 0 };\n    }\n    const uniforms = {\n        ...lighting.defaultUniforms,\n        ...prevUniforms,\n        ...getLightSourceUniforms({ ambientLight, pointLights, directionalLights })\n    };\n    if (props.enabled !== undefined) {\n        uniforms.enabled = props.enabled ? 1 : 0;\n    }\n    return uniforms;\n}\nfunction getLightSourceUniforms({ ambientLight, pointLights = [], directionalLights = [] }) {\n    const lightSourceUniforms = {\n    // lightType: new Array(MAX_LIGHTS).fill(0),\n    // lightColor: new Array(MAX_LIGHTS).fill([0, 0, 0]),\n    // lightPosition: new Array(MAX_LIGHTS).fill([0, 0, 0]),\n    // lightDirection: new Array(MAX_LIGHTS).fill([0, 0, 0]),\n    // lightAttenuation: new Array(MAX_LIGHTS).fill([0, 0, 0])\n    };\n    lightSourceUniforms.ambientLightColor = convertColor(ambientLight);\n    let currentLight = 0;\n    for (const pointLight of pointLights) {\n        // lightSourceUniforms.lightType[currentLight] = LIGHT_TYPE.POINT;\n        // lightSourceUniforms.lightColor[currentLight] = convertColor(pointLight);\n        // lightSourceUniforms.lightPosition[currentLight] = pointLight.position;\n        // lightSourceUniforms.lightAttenuation[currentLight] = [pointLight.attenuation || 1, 0, 0];\n        lightSourceUniforms.lightType = LIGHT_TYPE.POINT;\n        lightSourceUniforms.lightColor = convertColor(pointLight);\n        lightSourceUniforms.lightPosition = pointLight.position;\n        lightSourceUniforms.lightAttenuation = [pointLight.attenuation || 1, 0, 0];\n        currentLight++;\n    }\n    for (const directionalLight of directionalLights) {\n        // lightSourceUniforms.lightType[currentLight] = LIGHT_TYPE.DIRECTIONAL;\n        // lightSourceUniforms.lightColor[currentLight] = convertColor(directionalLight);\n        // lightSourceUniforms.lightPosition[currentLight] = directionalLight.position;\n        // lightSourceUniforms.lightDirection[currentLight] = directionalLight.direction;\n        lightSourceUniforms.lightType = LIGHT_TYPE.DIRECTIONAL;\n        lightSourceUniforms.lightColor = convertColor(directionalLight);\n        lightSourceUniforms.lightPosition = directionalLight.position;\n        lightSourceUniforms.lightDirection = directionalLight.direction;\n        currentLight++;\n    }\n    lightSourceUniforms.numberOfLights = currentLight;\n    return lightSourceUniforms;\n}\nfunction extractLightTypes(lights) {\n    const lightSources = { pointLights: [], directionalLights: [] };\n    for (const light of lights || []) {\n        switch (light.type) {\n            case 'ambient':\n                // Note: Only uses last ambient light\n                // TODO - add ambient light sources on CPU?\n                lightSources.ambientLight = light;\n                break;\n            case 'directional':\n                lightSources.directionalLights?.push(light);\n                break;\n            case 'point':\n                lightSources.pointLights?.push(light);\n                break;\n            default:\n            // eslint-disable-next-line\n            // console.warn(light.type);\n        }\n    }\n    return lightSources;\n}\n/** Take color 0-255 and intensity as input and output 0.0-1.0 range */\nfunction convertColor(colorDef = {}) {\n    const { color = [0, 0, 0], intensity = 1.0 } = colorDef;\n    return color.map(component => (component * intensity) / COLOR_FACTOR);\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// TODO\nexport const SOURCE_WGSL = /* WGSL */ `\\  \nstruct dirlightUniforms {\n  lightDirection: vec3<f32>,\n};\n\nalias DirlightNormal = vec3<f32>;\n\nstruct DirlightInputs {\n  normal: DirlightNormal,\n};\n\n@binding(1) @group(0) var<uniform> dirlight : dirlightUniforms;\n\n// For vertex\nfn dirlight_setNormal(normal: vec3<f32>) -> DirlightNormal {\n  return normalize(normal);\n}\n\n// Returns color attenuated by angle from light source\nfn dirlight_filterColor(color: vec4<f32>, inputs: DirlightInputs) -> vec4<f32> {\n  // TODO - fix default light direction\n  // let lightDirection = dirlight.lightDirection;\n  let lightDirection = vec3<f32>(1, 1, 1);\n  let d: f32 = abs(dot(inputs.normal, normalize(lightDirection)));\n  return vec4<f32>(color.rgb * d, color.a);\n}\n`;\nconst VS_GLSL = /* glsl */ `\\\nout vec3 dirlight_vNormal;\n\nvoid dirlight_setNormal(vec3 normal) {\n  dirlight_vNormal = normalize(normal);\n}\n`;\nconst FS_GLSL = /* glsl */ `\\\nuniform dirlightUniforms {\n  vec3 lightDirection;\n} dirlight;\n\nin vec3 dirlight_vNormal;\n\n// Returns color attenuated by angle from light source\nvec4 dirlight_filterColor(vec4 color) {\n  float d = abs(dot(dirlight_vNormal, normalize(dirlight.lightDirection)));\n  return vec4(color.rgb * d, color.a);\n}\n`;\n/**\n * Cheap lighting - single directional light, single dot product, one uniform\n */\nexport const dirlight = {\n    props: {},\n    uniforms: {},\n    name: 'dirlight',\n    dependencies: [],\n    source: SOURCE_WGSL,\n    vs: VS_GLSL,\n    fs: FS_GLSL,\n    // fragmentInputs: [\n    //   {\n    //     name: 'dirlight_vNormal',\n    //     type: 'vec3<f32>'\n    //   }\n    // ],\n    uniformTypes: {\n        lightDirection: 'vec3<f32>'\n    },\n    defaultUniforms: {\n        lightDirection: new Float32Array([1, 1, 2])\n    },\n    getUniforms\n};\nfunction getUniforms(opts = dirlight.defaultUniforms) {\n    const uniforms = {};\n    if (opts.lightDirection) {\n        // eslint-disable-next-line camelcase\n        uniforms.dirlight_uLightDirection = opts.lightDirection;\n    }\n    return uniforms;\n}\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const GOURAUD_VS = /* glsl */ `\\\nuniform materialUniforms {\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n`;\nexport const GOURAUD_FS = /* glsl */ `\\\nuniform materialUniforms {\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {\n  vec3 halfway_direction = normalize(light_direction + view_direction);\n  float lambertian = dot(light_direction, normal_worldspace);\n  float specular = 0.0;\n  if (lambertian > 0.0) {\n    float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);\n    specular = pow(specular_angle, material.shininess);\n  }\n  lambertian = max(lambertian, 0.0);\n  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;\n}\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = surfaceColor;\n\n  if (lighting.enabled) {\n    vec3 view_direction = normalize(cameraPosition - position_worldspace);\n    lightColor = material.ambient * surfaceColor * lighting.ambientColor;\n\n    if (lighting.lightType == 0) {\n      PointLight pointLight = lighting_getPointLight(0);\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    } else if (lighting.lightType == 1) {\n      DirectionalLight directionalLight = lighting_getDirectionalLight(0);\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n    /*\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.pointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting.pointLight[i];\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.directionalLightCount) {\n        break;\n      }\n      DirectionalLight directionalLight = lighting.directionalLight[i];\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n    */\n  }\n  return lightColor;\n}\n\nvec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = vec3(0, 0, 0);\n  vec3 surfaceColor = vec3(0, 0, 0);\n\n  if (lighting.enabled) {\n    vec3 view_direction = normalize(cameraPosition - position_worldspace);\n\n    switch (lighting.lightType) {\n      case 0:\n        PointLight pointLight = lighting_getPointLight(0);\n        vec3 light_position_worldspace = pointLight.position;\n        vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n        break;\n\n      case 1:\n        DirectionalLight directionalLight = lighting_getDirectionalLight(0);\n        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n        break;\n    }\n  }\n  return lightColor;\n}\n`;\n// TODO - handle multiple lights\n/**\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.pointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getPointLight(i);\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.directionalLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getDirectionalLight(i);\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n  }\n    /**\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.pointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getPointLight(i);\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.directionalLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getDirectionalLight(i);\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n  }\n  */\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { lighting } from \"../lights/lighting.js\";\nimport { GOURAUD_VS, GOURAUD_FS } from \"./gouraud-shaders-glsl.js\";\n/** In Gouraud shading, color is calculated for each triangle vertex normal, and then color is interpolated colors across the triangle */\nexport const gouraudMaterial = {\n    props: {},\n    uniforms: {},\n    name: 'gouraud-lighting',\n    // Note these are switched between phong and gouraud\n    vs: GOURAUD_VS,\n    fs: GOURAUD_FS,\n    defines: {\n        LIGHTING_VERTEX: 1\n    },\n    dependencies: [lighting],\n    uniformTypes: {\n        ambient: 'f32',\n        diffuse: 'f32',\n        shininess: 'f32',\n        specularColor: 'vec3<f32>'\n    },\n    defaultUniforms: {\n        ambient: 0.35,\n        diffuse: 0.6,\n        shininess: 32,\n        specularColor: [0.15, 0.15, 0.15]\n    },\n    getUniforms(props) {\n        return { ...gouraudMaterial.defaultUniforms, ...props };\n    }\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const PHONG_WGSL = /* wgsl */ `\\\nstruct phongMaterialUniforms {\n  ambient: f32,\n  diffuse: f32,\n  shininess: f32,\n  specularColor: vec3<f32>,\n};\n\n@binding(2) @group(0) var<uniform> material : phongMaterialUniforms;\n\nfn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, view_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {\n  let halfway_direction: vec3<f32> = normalize(light_direction + view_direction);\n  var lambertian: f32 = dot(light_direction, normal_worldspace);\n  var specular: f32 = 0.0;\n  if (lambertian > 0.0) {\n    let specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);\n    specular = pow(specular_angle, material.shininess);\n  }\n  lambertian = max(lambertian, 0.0);\n  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;\n}\n\nfn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {\n  var lightColor: vec3<f32> = surfaceColor;\n\n  if (lighting.enabled == 0) {\n    return lightColor;\n  }\n\n  let view_direction: vec3<f32> = normalize(cameraPosition - position_worldspace);\n  lightColor = material.ambient * surfaceColor * lighting.ambientColor;\n\n  if (lighting.lightType == 0) {\n    let pointLight: PointLight  = lighting_getPointLight(0);\n    let light_position_worldspace: vec3<f32> = pointLight.position;\n    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);\n    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n  } else if (lighting.lightType == 1) {\n    var directionalLight: DirectionalLight = lighting_getDirectionalLight(0);\n    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n  }\n  \n  return lightColor;\n  /*\n  for (int i = 0; i < MAX_LIGHTS; i++) {\n    if (i >= lighting.pointLightCount) {\n      break;\n    }\n    PointLight pointLight = lighting.pointLight[i];\n    vec3 light_position_worldspace = pointLight.position;\n    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n  }\n\n  for (int i = 0; i < MAX_LIGHTS; i++) {\n    if (i >= lighting.directionalLightCount) {\n      break;\n    }\n    DirectionalLight directionalLight = lighting.directionalLight[i];\n    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n  }\n  */\n}\n\nfn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32>{\n  var lightColor = vec3<f32>(0, 0, 0);\n  let surfaceColor = vec3<f32>(0, 0, 0);\n\n  if (lighting.enabled == 0) {\n    let view_direction = normalize(cameraPosition - position_worldspace);\n\n    switch (lighting.lightType) {\n      case 0, default: {\n        let pointLight: PointLight = lighting_getPointLight(0);\n        let light_position_worldspace: vec3<f32> = pointLight.position;\n        let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);\n        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n      }\n      case 1: {\n        let directionalLight: DirectionalLight = lighting_getDirectionalLight(0);\n        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n      }\n    }\n  }\n  return lightColor;\n}\n`;\n// TODO - handle multiple lights\n/**\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.pointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getPointLight(i);\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.directionalLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getDirectionalLight(i);\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n  }\n    /**\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.pointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getPointLight(i);\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.directionalLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getDirectionalLight(i);\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n  }\n  */\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const PHONG_VS = /* glsl */ `\\\nuniform phongMaterialUniforms {\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n`;\nexport const PHONG_FS = /* glsl */ `\\\nuniform phongMaterialUniforms {\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {\n  vec3 halfway_direction = normalize(light_direction + view_direction);\n  float lambertian = dot(light_direction, normal_worldspace);\n  float specular = 0.0;\n  if (lambertian > 0.0) {\n    float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);\n    specular = pow(specular_angle, material.shininess);\n  }\n  lambertian = max(lambertian, 0.0);\n  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;\n}\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = surfaceColor;\n\n  if (lighting.enabled == 0) {\n    return lightColor;\n  }\n\n  vec3 view_direction = normalize(cameraPosition - position_worldspace);\n  lightColor = material.ambient * surfaceColor * lighting.ambientColor;\n\n  if (lighting.lightType == 0) {\n    PointLight pointLight = lighting_getPointLight(0);\n    vec3 light_position_worldspace = pointLight.position;\n    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n  } else if (lighting.lightType == 1) {\n    DirectionalLight directionalLight = lighting_getDirectionalLight(0);\n    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n  }\n  \n  /*\n  for (int i = 0; i < MAX_LIGHTS; i++) {\n    if (i >= lighting.pointLightCount) {\n      break;\n    }\n    PointLight pointLight = lighting.pointLight[i];\n    vec3 light_position_worldspace = pointLight.position;\n    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n  }\n\n  for (int i = 0; i < MAX_LIGHTS; i++) {\n    if (i >= lighting.directionalLightCount) {\n      break;\n    }\n    DirectionalLight directionalLight = lighting.directionalLight[i];\n    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n  }\n  */\n  return lightColor;\n}\n\nvec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = vec3(0, 0, 0);\n  vec3 surfaceColor = vec3(0, 0, 0);\n\n  if (lighting.enabled == 0) {\n    vec3 view_direction = normalize(cameraPosition - position_worldspace);\n\n    switch (lighting.lightType) {\n      case 0:\n        PointLight pointLight = lighting_getPointLight(0);\n        vec3 light_position_worldspace = pointLight.position;\n        vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n        break;\n\n      case 1:\n        DirectionalLight directionalLight = lighting_getDirectionalLight(0);\n        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n        break;\n    }\n  }\n  return lightColor;\n}\n`;\n// TODO - handle multiple lights\n/**\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.pointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getPointLight(i);\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.directionalLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getDirectionalLight(i);\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n  }\n    /**\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.pointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getPointLight(i);\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.directionalLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_getDirectionalLight(i);\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n  }\n  */\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { lighting } from \"../lights/lighting.js\";\nimport { PHONG_WGSL } from \"./phong-shaders-wgsl.js\";\nimport { PHONG_VS, PHONG_FS } from \"./phong-shaders-glsl.js\";\n/** In Phong shading, the normal vector is linearly interpolated across the surface of the polygon from the polygon's vertex normals. */\nexport const phongMaterial = {\n    props: {},\n    uniforms: {},\n    name: 'phong-lighting',\n    dependencies: [lighting],\n    // Note these are switched between phong and gouraud\n    source: PHONG_WGSL,\n    vs: PHONG_VS,\n    fs: PHONG_FS,\n    defines: {\n        LIGHTING_FRAGMENT: 1\n    },\n    uniformTypes: {\n        ambient: 'f32',\n        diffuse: 'f32',\n        shininess: 'f32',\n        specularColor: 'vec3<f32>'\n    },\n    defaultUniforms: {\n        ambient: 0.35,\n        diffuse: 0.6,\n        shininess: 32,\n        specularColor: [0.15, 0.15, 0.15]\n    },\n    getUniforms(props) {\n        return { ...phongMaterial.defaultUniforms, ...props };\n    }\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const vs = /* glsl */ `\\\nuniform projection {\n  mat4 u_MVPMatrix;\n  mat4 u_ModelMatrix;\n  mat4 u_NormalMatrix;\n  // Projection\n  vec3 u_Camera;\n}\n\nvarying vec3 pbr_vPosition;\nvarying vec2 pbr_vUV;\n\n#ifdef HAS_NORMALS\n# ifdef HAS_TANGENTS\nvarying mat3 pbr_vTBN;\n# else\nvarying vec3 pbr_vNormal;\n# endif\n#endif\n\nvoid pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)\n{\n  vec4 pos = u_ModelMatrix * position;\n  pbr_vPosition = vec3(pos.xyz) / pos.w;\n\n#ifdef HAS_NORMALS\n#ifdef HAS_TANGENTS\n  vec3 normalW = normalize(vec3(u_NormalMatrix * vec4(normal.xyz, 0.0)));\n  vec3 tangentW = normalize(vec3(u_ModelMatrix * vec4(tangent.xyz, 0.0)));\n  vec3 bitangentW = cross(normalW, tangentW) * tangent.w;\n  pbr_vTBN = mat3(tangentW, bitangentW, normalW);\n#else // HAS_TANGENTS != 1\n  pbr_vNormal = normalize(vec3(u_ModelMatrix * vec4(normal.xyz, 0.0)));\n#endif\n#endif\n\n#ifdef HAS_UV\n  pbr_vUV = uv;\n#else\n  pbr_vUV = vec2(0.,0.);\n#endif\n}\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// Attribution:\n// MIT license, Copyright (c) 2016-2017 Mohamad Moneimne and Contributors\n// This fragment shader defines a reference implementation for Physically Based Shading of\n// a microfacet surface material defined by a glTF model.\n// TODO - better do the checks outside of shader\nexport const fs = /* glsl */ `\\\nprecision highp float;\n\nuniform Projection {\n  // Projection\n  uniform vec3 u_Camera;\n};\n\nuniform pbrMaterial {\n  // Material is unlit\n  bool unlit;\n\n  // Base color map\n  bool baseColorMapEnabled;\n  vec4 baseColorFactor;\n\n  bool normalMapEnabled;  \n  float normalScale; // #ifdef HAS_NORMALMAP\n\n  bool emissiveMapEnabled;\n  vec3 emissiveFactor; // #ifdef HAS_EMISSIVEMAP\n\n  vec2 metallicRoughnessValues;\n  bool metallicRoughnessMapEnabled;\n\n  bool occlusionMapEnabled;\n  float occlusionStrength; // #ifdef HAS_OCCLUSIONMAP\n  \n  bool alphaCutoffEnabled;\n  float alphaCutoff; // #ifdef ALPHA_CUTOFF\n  \n  // IBL\n  bool IBLenabled;\n  vec2 scaleIBLAmbient; // #ifdef USE_IBL\n  \n  // debugging flags used for shader output of intermediate PBR variables\n  // #ifdef PBR_DEBUG\n  vec4 scaleDiffBaseMR;\n  vec4 scaleFGDSpec;\n  // #endif\n} u_pbrMaterial;\n\n// Samplers\n#ifdef HAS_BASECOLORMAP\nuniform sampler2D u_BaseColorSampler;\n#endif\n#ifdef HAS_NORMALMAP\nuniform sampler2D u_NormalSampler;\n#endif\n#ifdef HAS_EMISSIVEMAP\nuniform sampler2D u_EmissiveSampler;\n#endif\n#ifdef HAS_METALROUGHNESSMAP\nuniform sampler2D u_MetallicRoughnessSampler;\n#endif\n#ifdef HAS_OCCLUSIONMAP\nuniform sampler2D u_OcclusionSampler;\n#endif\n#ifdef USE_IBL\nuniform samplerCube u_DiffuseEnvSampler;\nuniform samplerCube u_SpecularEnvSampler;\nuniform sampler2D u_brdfLUT;\n#endif\n\n// Inputs from vertex shader\n\nvarying vec3 pbr_vPosition;\nvarying vec2 pbr_vUV;\n\n#ifdef HAS_NORMALS\n#ifdef HAS_TANGENTS\nvarying mat3 pbr_vTBN;\n#else\nvarying vec3 pbr_vNormal;\n#endif\n#endif\n\n// Encapsulate the various inputs used by the various functions in the shading equation\n// We store values in this struct to simplify the integration of alternative implementations\n// of the shading terms, outlined in the Readme.MD Appendix.\nstruct PBRInfo {\n  float NdotL;                  // cos angle between normal and light direction\n  float NdotV;                  // cos angle between normal and view direction\n  float NdotH;                  // cos angle between normal and half vector\n  float LdotH;                  // cos angle between light direction and half vector\n  float VdotH;                  // cos angle between view direction and half vector\n  float perceptualRoughness;    // roughness value, as authored by the model creator (input to shader)\n  float metalness;              // metallic value at the surface\n  vec3 reflectance0;            // full reflectance color (normal incidence angle)\n  vec3 reflectance90;           // reflectance color at grazing angle\n  float alphaRoughness;         // roughness mapped to a more linear change in the roughness (proposed by [2])\n  vec3 diffuseColor;            // color contribution from diffuse lighting\n  vec3 specularColor;           // color contribution from specular lighting\n  vec3 n;                       // normal at surface point\n  vec3 v;                       // vector from surface point to camera\n};\n\nconst float M_PI = 3.141592653589793;\nconst float c_MinRoughness = 0.04;\n\nvec4 SRGBtoLINEAR(vec4 srgbIn)\n{\n#ifdef MANUAL_SRGB\n#ifdef SRGB_FAST_APPROXIMATION\n  vec3 linOut = pow(srgbIn.xyz,vec3(2.2));\n#else // SRGB_FAST_APPROXIMATION\n  vec3 bLess = step(vec3(0.04045),srgbIn.xyz);\n  vec3 linOut = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );\n#endif //SRGB_FAST_APPROXIMATION\n  return vec4(linOut,srgbIn.w);;\n#else //MANUAL_SRGB\n  return srgbIn;\n#endif //MANUAL_SRGB\n}\n\n// Find the normal for this fragment, pulling either from a predefined normal map\n// or from the interpolated mesh normal and tangent attributes.\nvec3 getNormal()\n{\n  // Retrieve the tangent space matrix\n#ifndef HAS_TANGENTS\n  vec3 pos_dx = dFdx(pbr_vPosition);\n  vec3 pos_dy = dFdy(pbr_vPosition);\n  vec3 tex_dx = dFdx(vec3(pbr_vUV, 0.0));\n  vec3 tex_dy = dFdy(vec3(pbr_vUV, 0.0));\n  vec3 t = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);\n\n#ifdef HAS_NORMALS\n  vec3 ng = normalize(pbr_vNormal);\n#else\n  vec3 ng = cross(pos_dx, pos_dy);\n#endif\n\n  t = normalize(t - ng * dot(ng, t));\n  vec3 b = normalize(cross(ng, t));\n  mat3 tbn = mat3(t, b, ng);\n#else // HAS_TANGENTS\n  mat3 tbn = pbr_vTBN;\n#endif\n\n#ifdef HAS_NORMALMAP\n  vec3 n = texture2D(u_NormalSampler, pbr_vUV).rgb;\n  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(u_pbrMaterial.normalScale, u_pbrMaterial.normalScale, 1.0)));\n#else\n  // The tbn matrix is linearly interpolated, so we need to re-normalize\n  vec3 n = normalize(tbn[2].xyz);\n#endif\n\n  return n;\n}\n\n// Calculation of the lighting contribution from an optional Image Based Light source.\n// Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].\n// See our README.md on Environment Maps [3] for additional discussion.\n#ifdef USE_IBL\nvec3 getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection)\n{\n  float mipCount = 9.0; // resolution of 512x512\n  float lod = (pbrInfo.perceptualRoughness * mipCount);\n  // retrieve a scale and bias to F0. See [1], Figure 3\n  vec3 brdf = SRGBtoLINEAR(texture2D(u_brdfLUT,\n    vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness))).rgb;\n  vec3 diffuseLight = SRGBtoLINEAR(textureCube(u_DiffuseEnvSampler, n)).rgb;\n\n#ifdef USE_TEX_LOD\n  vec3 specularLight = SRGBtoLINEAR(textureCubeLod(u_SpecularEnvSampler, reflection, lod)).rgb;\n#else\n  vec3 specularLight = SRGBtoLINEAR(textureCube(u_SpecularEnvSampler, reflection)).rgb;\n#endif\n\n  vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;\n  vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);\n\n  // For presentation, this allows us to disable IBL terms\n  diffuse *= u_pbrMaterial.scaleIBLAmbient.x;\n  specular *= u_pbrMaterial.scaleIBLAmbient.y;\n\n  return diffuse + specular;\n}\n#endif\n\n// Basic Lambertian diffuse\n// Implementation from Lambert's Photometria https://archive.org/details/lambertsphotome00lambgoog\n// See also [1], Equation 1\nvec3 diffuse(PBRInfo pbrInfo)\n{\n  return pbrInfo.diffuseColor / M_PI;\n}\n\n// The following equation models the Fresnel reflectance term of the spec equation (aka F())\n// Implementation of fresnel from [4], Equation 15\nvec3 specularReflection(PBRInfo pbrInfo)\n{\n  return pbrInfo.reflectance0 +\n    (pbrInfo.reflectance90 - pbrInfo.reflectance0) *\n    pow(clamp(1.0 - pbrInfo.VdotH, 0.0, 1.0), 5.0);\n}\n\n// This calculates the specular geometric attenuation (aka G()),\n// where rougher material will reflect less light back to the viewer.\n// This implementation is based on [1] Equation 4, and we adopt their modifications to\n// alphaRoughness as input as originally proposed in [2].\nfloat geometricOcclusion(PBRInfo pbrInfo)\n{\n  float NdotL = pbrInfo.NdotL;\n  float NdotV = pbrInfo.NdotV;\n  float r = pbrInfo.alphaRoughness;\n\n  float attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));\n  float attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));\n  return attenuationL * attenuationV;\n}\n\n// The following equation(s) model the distribution of microfacet normals across\n// the area being drawn (aka D())\n// Implementation from \"Average Irregularity Representation of a Roughened Surface\n// for Ray Reflection\" by T. S. Trowbridge, and K. P. Reitz\n// Follows the distribution function recommended in the SIGGRAPH 2013 course notes\n// from EPIC Games [1], Equation 3.\nfloat microfacetDistribution(PBRInfo pbrInfo)\n{\n  float roughnessSq = pbrInfo.alphaRoughness * pbrInfo.alphaRoughness;\n  float f = (pbrInfo.NdotH * roughnessSq - pbrInfo.NdotH) * pbrInfo.NdotH + 1.0;\n  return roughnessSq / (M_PI * f * f);\n}\n\nvoid PBRInfo_setAmbientLight(inout PBRInfo pbrInfo) {\n  pbrInfo.NdotL = 1.0;\n  pbrInfo.NdotH = 0.0;\n  pbrInfo.LdotH = 0.0;\n  pbrInfo.VdotH = 1.0;\n}\n\nvoid PBRInfo_setDirectionalLight(inout PBRInfo pbrInfo, vec3 lightDirection) {\n  vec3 n = pbrInfo.n;\n  vec3 v = pbrInfo.v;\n  vec3 l = normalize(lightDirection);             // Vector from surface point to light\n  vec3 h = normalize(l+v);                        // Half vector between both l and v\n\n  pbrInfo.NdotL = clamp(dot(n, l), 0.001, 1.0);\n  pbrInfo.NdotH = clamp(dot(n, h), 0.0, 1.0);\n  pbrInfo.LdotH = clamp(dot(l, h), 0.0, 1.0);\n  pbrInfo.VdotH = clamp(dot(v, h), 0.0, 1.0);\n}\n\nvoid PBRInfo_setPointLight(inout PBRInfo pbrInfo, PointLight pointLight) {\n  vec3 light_direction = normalize(pointLight.position - pbr_vPosition);\n  PBRInfo_setDirectionalLight(pbrInfo, light_direction);\n}\n\nvec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor) {\n  // Calculate the shading terms for the microfacet specular shading model\n  vec3 F = specularReflection(pbrInfo);\n  float G = geometricOcclusion(pbrInfo);\n  float D = microfacetDistribution(pbrInfo);\n\n  // Calculation of analytical lighting contribution\n  vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInfo);\n  vec3 specContrib = F * G * D / (4.0 * pbrInfo.NdotL * pbrInfo.NdotV);\n  // Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)\n  return pbrInfo.NdotL * lightColor * (diffuseContrib + specContrib);\n}\n\nvec4 pbr_filterColor(vec4 colorUnused)\n{\n  // The albedo may be defined from a base texture or a flat color\n#ifdef HAS_BASECOLORMAP\n  vec4 baseColor = SRGBtoLINEAR(texture2D(u_BaseColorSampler, pbr_vUV)) * u_pbrMaterial.baseColorFactor;\n#else\n  vec4 baseColor = u_pbrMaterial.baseColorFactor;\n#endif\n\n#ifdef ALPHA_CUTOFF\n  if (baseColor.a < u_pbrMaterial.alphaCutoff) {\n    discard;\n  }\n#endif\n\n  vec3 color = vec3(0, 0, 0);\n\n  if(u_pbrMaterial.unlit){\n    color.rgb = baseColor.rgb;\n  }\n  else{\n    // Metallic and Roughness material properties are packed together\n    // In glTF, these factors can be specified by fixed scalar values\n    // or from a metallic-roughness map\n    float perceptualRoughness = u_pbrMaterial.metallicRoughnessValues.y;\n    float metallic = u_pbrMaterial.metallicRoughnessValues.x;\n#ifdef HAS_METALROUGHNESSMAP\n    // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.\n    // This layout intentionally reserves the 'r' channel for (optional) occlusion map data\n    vec4 mrSample = texture2D(u_MetallicRoughnessSampler, pbr_vUV);\n    perceptualRoughness = mrSample.g * perceptualRoughness;\n    metallic = mrSample.b * metallic;\n#endif\n    perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);\n    metallic = clamp(metallic, 0.0, 1.0);\n    // Roughness is authored as perceptual roughness; as is convention,\n    // convert to material roughness by squaring the perceptual roughness [2].\n    float alphaRoughness = perceptualRoughness * perceptualRoughness;\n\n    vec3 f0 = vec3(0.04);\n    vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);\n    diffuseColor *= 1.0 - metallic;\n    vec3 specularColor = mix(f0, baseColor.rgb, metallic);\n\n    // Compute reflectance.\n    float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);\n\n    // For typical incident reflectance range (between 4% to 100%) set the grazing\n    // reflectance to 100% for typical fresnel effect.\n    // For very low reflectance range on highly diffuse objects (below 4%),\n    // incrementally reduce grazing reflecance to 0%.\n    float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);\n    vec3 specularEnvironmentR0 = specularColor.rgb;\n    vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;\n\n    vec3 n = getNormal();                          // normal at surface point\n    vec3 v = normalize(u_Camera - pbr_vPosition);  // Vector from surface point to camera\n\n    float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);\n    vec3 reflection = -normalize(reflect(v, n));\n\n    PBRInfo pbrInfo = PBRInfo(\n      0.0, // NdotL\n      NdotV,\n      0.0, // NdotH\n      0.0, // LdotH\n      0.0, // VdotH\n      perceptualRoughness,\n      metallic,\n      specularEnvironmentR0,\n      specularEnvironmentR90,\n      alphaRoughness,\n      diffuseColor,\n      specularColor,\n      n,\n      v\n    );\n\n#ifdef USE_LIGHTS\n    // Apply ambient light\n    PBRInfo_setAmbientLight(pbrInfo);\n    color += calculateFinalColor(pbrInfo, lighting_uAmbientLight.color);\n\n    // Apply directional light\n    for(int i = 0; i < lighting_uDirectionalLightCount; i++) {\n      if (i < lighting_uDirectionalLightCount) {\n        PBRInfo_setDirectionalLight(pbrInfo, lighting_uDirectionalLight[i].direction);\n        color += calculateFinalColor(pbrInfo, lighting_uDirectionalLight[i].color);\n      }\n    }\n\n    // Apply point light\n    for(int i = 0; i < lighting_uPointLightCount; i++) {\n      if (i < lighting_uPointLightCount) {\n        PBRInfo_setPointLight(pbrInfo, lighting_uPointLight[i]);\n        float attenuation = getPointLightAttenuation(lighting_uPointLight[i], distance(lighting_uPointLight[i].position, pbr_vPosition));\n        color += calculateFinalColor(pbrInfo, lighting_uPointLight[i].color / attenuation);\n      }\n    }\n#endif\n\n    // Calculate lighting contribution from image based lighting source (IBL)\n#ifdef USE_IBL\n    if (u_pbrMateral.IBLEnabled) {\n      color += getIBLContribution(pbrInfo, n, reflection);\n    }\n#endif\n\n    // Apply optional PBR terms for additional (optional) shading\n#ifdef HAS_OCCLUSIONMAP\n    if (u_pbrMaterial.occlusionMapEnabled) {\n      float ao = texture2D(u_OcclusionSampler, pbr_vUV).r;\n      color = mix(color, color * ao, u_pbrMaterial.occlusionStrength);\n    }\n#endif\n\n#ifdef HAS_EMISSIVEMAP\n    if (u_pbrMaterial.emmissiveMapEnabled) {\n      vec3 emissive = SRGBtoLINEAR(texture2D(u_EmissiveSampler, pbr_vUV)).rgb * u_pbrMaterial.emissiveFactor;\n      color += emissive;\n    }\n#endif\n\n    // This section uses mix to override final color for reference app visualization\n    // of various parameters in the lighting equation.\n#ifdef PBR_DEBUG\n    // TODO: Figure out how to debug multiple lights\n\n    // color = mix(color, F, u_ScaleFGDSpec.x);\n    // color = mix(color, vec3(G), u_ScaleFGDSpec.y);\n    // color = mix(color, vec3(D), u_ScaleFGDSpec.z);\n    // color = mix(color, specContrib, u_ScaleFGDSpec.w);\n\n    // color = mix(color, diffuseContrib, u_ScaleDiffBaseMR.x);\n    color = mix(color, baseColor.rgb, u_pbrMaterial.scaleDiffBaseMR.y);\n    color = mix(color, vec3(metallic), u_pbrMaterial.scaleDiffBaseMR.z);\n    color = mix(color, vec3(perceptualRoughness), u_pbrMaterial.scaleDiffBaseMR.w);\n#endif\n\n  }\n\n  return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);\n}\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { lighting } from \"../lights/lighting.js\";\nimport { vs } from \"./pbr-vertex-glsl.js\";\nimport { fs } from \"./pbr-fragment-glsl.js\";\n/**\n * An implementation of PBR (Physically-Based Rendering).\n * Physically Based Shading of a microfacet surface defined by a glTF material.\n */\nexport const pbrMaterial = {\n    props: {},\n    uniforms: {},\n    name: 'pbr',\n    dependencies: [lighting],\n    vs,\n    fs,\n    defines: {\n        LIGHTING_FRAGMENT: 1,\n        HAS_NORMALMAP: 0,\n        HAS_EMISSIVEMAP: 0,\n        HAS_OCCLUSIONMAP: 0,\n        HAS_BASECOLORMAP: 0,\n        HAS_METALROUGHNESSMAP: 0,\n        ALPHA_CUTOFF: 0,\n        USE_IBL: 0,\n        PBR_DEBUG: 0\n    },\n    uniformTypes: {\n        // Material is unlit\n        unlit: 'i32',\n        // Base color map\n        baseColorMapEnabled: 'i32',\n        baseColorFactor: 'vec4<f32>',\n        normalMapEnabled: 'i32',\n        normalScale: 'f32', // #ifdef HAS_NORMALMAP\n        emissiveMapEnabled: 'i32',\n        emissiveFactor: 'vec3<f32>', // #ifdef HAS_EMISSIVEMAP\n        metallicRoughnessValues: 'vec2<f32>',\n        metallicRoughnessMapEnabled: 'i32',\n        occlusionMapEnabled: 'i32',\n        occlusionStrength: 'f32', // #ifdef HAS_OCCLUSIONMAP\n        alphaCutoffEnabled: 'i32',\n        alphaCutoff: 'f32', // #ifdef ALPHA_CUTOFF\n        // IBL\n        IBLenabled: 'i32',\n        scaleIBLAmbient: 'vec2<f32>', // #ifdef USE_IBL\n        // debugging flags used for shader output of intermediate PBR variables\n        // #ifdef PBR_DEBUG\n        scaleDiffBaseMR: 'vec4<f32>',\n        scaleFGDSpec: 'vec4<f32>'\n    },\n    bindings: {\n        baseColorSampler: { type: 'texture', location: 8 }, // #ifdef HAS_BASECOLORMAP\n        normalSampler: { type: 'texture', location: 9 }, // #ifdef HAS_NORMALMAP\n        emissiveSampler: { type: 'texture', location: 10 }, // #ifdef HAS_EMISSIVEMAP\n        metallicRoughnessSampler: { type: 'texture', location: 11 }, // #ifdef HAS_METALROUGHNESSMAP\n        occlusionSampler: { type: 'texture', location: 12 }, // #ifdef HAS_OCCLUSIONMAP\n        // IBL Samplers\n        diffuseEnvSampler: { type: 'texture', location: 13 }, // #ifdef USE_IBL (samplerCube)\n        specularEnvSampler: { type: 'texture', location: 14 }, // #ifdef USE_IBL (samplerCube)\n        brdfLUT: { type: 'texture', location: 15 } // #ifdef USE_IBL\n    }\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\n\nuniform brightnessContrastUniforms {\n  float brightness;\n  float contrast;\n} brightnessContrast;\n\nvec4 brightnessContrast_filterColor(vec4 color) {\n  color.rgb += brightnessContrast.brightness;\n  if (brightnessContrast.contrast > 0.0) {\n    color.rgb = (color.rgb - 0.5) / (1.0 - brightnessContrast.contrast) + 0.5;\n  } else {\n    color.rgb = (color.rgb - 0.5) * (1.0 + brightnessContrast.contrast) + 0.5;\n  }\n  return color;\n}\n\nvec4 brightnessContrast_filterColor(vec4 color, vec2 texSize, vec2 texCoords) {\n  return brightnessContrast_filterColor(color);\n}\n`;\n/**\n * Brightness / Contrast -\n * Provides additive brightness and multiplicative contrast control.\n * @param brightness -1 to 1 (-1 is solid black, 0 is no change, and 1 is solid white)\n * @param contrast   -1 to 1 (-1 is solid gray, 0 is no change, and 1 is maximum contrast)\n */\nexport const brightnessContrast = {\n    props: {},\n    uniforms: {},\n    name: 'brightnessContrast',\n    uniformTypes: {\n        brightness: 'f32',\n        contrast: 'f32'\n    },\n    uniformPropTypes: {\n        brightness: { format: 'f32', value: 0, min: -1, max: 1 },\n        contrast: { format: 'f32', value: 0, min: -1, max: 1 }\n    },\n    fs,\n    passes: [{ filter: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// Do a 9x9 bilateral box filter\nconst fs = /* glsl */ `\\\nuniform denoiseUniforms {\n  float strength;\n} noise;\n\nvec4 denoise_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  float adjustedExponent = 3. + 200. * pow(1. - noise.strength, 4.);\n\n  vec4 center = texture(source, texCoord);\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n  for (float x = -4.0; x <= 4.0; x += 1.0) {\n    for (float y = -4.0; y <= 4.0; y += 1.0) {\n      vec4 offsetColor = texture(source, texCoord + vec2(x, y) / texSize);\n      float weight = 1.0 - abs(dot(offsetColor.rgb - center.rgb, vec3(0.25)));\n      weight = pow(weight, adjustedExponent);\n      color += offsetColor * weight;\n      total += weight;\n    }\n  }\n\n  return color / total;\n}\n`;\n/**\n * Denoise -\n * Smooths over grainy noise in dark images using an 9x9 box filter\n * weighted by color intensity, similar to a bilateral filter.\n */\nexport const denoise = {\n    props: {},\n    uniforms: {},\n    name: 'denoise',\n    uniformTypes: {\n        strength: 'f32'\n    },\n    uniformPropTypes: {\n        strength: { format: 'f32', value: 0.5, min: 0, max: 1 }\n        // strength: {..., adjust: (strength: number): number => 0.53 + 200 * Math.pow(1 - strength, 4) // TODO - JS preprocessing\n    },\n    fs,\n    passes: [{ sampler: true }, { sampler: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nuniform hueSaturationUniforms {\n  float hue;\n  float saturation;\n} hueSaturation;\n\nvec4 hueSaturation_filterColor(vec4 color) {\n  // hue adjustment, wolfram alpha: RotationTransform[angle, {1, 1, 1}][{x, y, z}]\n  float angle = hueSaturation.hue * 3.14159265;\n  float s = sin(angle), c = cos(angle);\n  vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;\n  float len = length(color.rgb);\n  color.rgb = vec3(\n    dot(color.rgb, weights.xyz),\n    dot(color.rgb, weights.zxy),\n    dot(color.rgb, weights.yzx)\n  );\n\n  // saturation adjustment\n  float average = (color.r + color.g + color.b) / 3.0;\n  if (hueSaturation.saturation > 0.0) {\n    color.rgb += (average - color.rgb) * (1.0 - 1.0 / (1.001 - hueSaturation.saturation));\n  } else {\n    color.rgb += (average - color.rgb) * (-hueSaturation.saturation);\n  }\n\n  return color;\n}\n\nvec4 hueSaturation_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return hueSaturation_filterColor(color);\n}\n`;\n/**\n * Hue / Saturation\n * Provides rotational hue and multiplicative saturation control. RGB color space\n * can be imagined as a cube where the axes are the red, green, and blue color\n * values. Hue changing works by rotating the color vector around the grayscale\n * line, which is the straight line from black (0, 0, 0) to white (1, 1, 1).\n * Saturation is implemented by scaling all color channel values either toward\n * or away from the average color channel value.\n */\nexport const hueSaturation = {\n    props: {},\n    uniforms: {},\n    name: 'hueSaturation',\n    fs,\n    uniformTypes: {\n        hue: 'f32',\n        saturation: 'f32'\n    },\n    uniformPropTypes: {\n        hue: { value: 0, min: -1, max: 1 },\n        saturation: { value: 0, min: -1, max: 1 }\n    },\n    passes: [{ filter: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nuniform noiseUniforms {\n  float amount;\n} noise;\n\nfloat rand(vec2 co) {\n  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);\n}\n\nvec4 noise_filterColor(vec4 color, vec2 texCoord) {\n  float diff = (rand(texCoord) - 0.5) * noise.amount;\n  color.r += diff;\n  color.g += diff;\n  color.b += diff;\n  return color;\n}\n\nvec4 noise_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return noise_filterColor(color, texCoord);\n}\n`;\n/**\n * Noise\n * Adds black and white noise to the image.\n */\nexport const noise = {\n    props: {},\n    uniforms: {},\n    name: 'noise',\n    uniformTypes: {\n        amount: 'f32'\n    },\n    uniformPropTypes: {\n        amount: { value: 0.5, min: 0, max: 1 }\n    },\n    fs,\n    passes: [{ filter: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nuniform sepiaUniforms {\n  float amount;\n} sepia;\n\nvec4 sepia_filterColor(vec4 color) {\n  float r = color.r;\n  float g = color.g;\n  float b = color.b;\n\n  color.r =\n    min(1.0, (r * (1.0 - (0.607 * sepia.amount))) + (g * (0.769 * sepia.amount)) + (b * (0.189 * sepia.amount)));\n  color.g = min(1.0, (r * 0.349 * sepia.amount) + (g * (1.0 - (0.314 * sepia.amount))) + (b * 0.168 * sepia.amount));\n  color.b = min(1.0, (r * 0.272 * sepia.amount) + (g * 0.534 * sepia.amount) + (b * (1.0 - (0.869 * sepia.amount))));\n\n  return color;\n}\n\nvec4 sepia_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return sepia_filterColor(color);\n}\n`;\n/**\n * @filter         Sepia\n * @description    Gives the image a reddish-brown monochrome tint that imitates an old photograph.\n * @param amount   0 to 1 (0 for no effect, 1 for full sepia coloring)\n */\nexport const sepia = {\n    props: {},\n    uniforms: {},\n    name: 'sepia',\n    uniformTypes: {\n        amount: 'f32'\n    },\n    uniformPropTypes: {\n        amount: { value: 0.5, min: 0, max: 1 }\n    },\n    fs,\n    passes: [{ filter: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nuniform vibranceUniforms {\n  float amount;\n} vibrance;\n\nvec4 vibrance_filterColor(vec4 color) {\n  float average = (color.r + color.g + color.b) / 3.0;\n  float mx = max(color.r, max(color.g, color.b));\n  float amt = (mx - average) * (-vibrance.amount * 3.0);\n  color.rgb = mix(color.rgb, vec3(mx), amt);\n  return color;\n}\n\nvec4 vibrance_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return vibrance_filterColor(color);\n}\n`;\n/** Vibrance - Modifies the saturation of desaturated colors, leaving saturated colors unmodified. */\nexport const vibrance = {\n    props: {},\n    uniforms: {},\n    name: 'vibrance',\n    uniformPropTypes: {\n        amount: { value: 0, min: -1, max: 1 }\n    },\n    fs,\n    passes: [{ filter: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nuniform vignetteUniforms {\n  float radius;\n  float amount;\n} vignette;\n\nvec4 vignette_filterColor(vec4 color, vec2 texCoord) {\n  float dist = distance(texCoord, vec2(0.5, 0.5));\n  float ratio = smoothstep(0.8, vignette.radius * 0.799, dist * (vignette.amount + vignette.radius));\n  return color.rgba * ratio + (1.0 - ratio)*vec4(0.0, 0.0, 0.0, 1.0);\n}\n\nvec4 vignette_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return vignette_filterColor(color, texCoord);\n}\n`;\n/**\n * Vignette -\n * Adds a simulated lens edge darkening effect.\n */\nexport const vignette = {\n    props: {},\n    uniforms: {},\n    name: 'vignette',\n    uniformTypes: {\n        radius: 'f32',\n        amount: 'f32'\n    },\n    uniformPropTypes: {\n        radius: { value: 0.5, min: 0, max: 1 },\n        amount: { value: 0.5, min: 0, max: 1 }\n    },\n    passes: [{ filter: true }],\n    fs\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { random } from \"../..//math/random/random.js\";\nconst fs = /* glsl */ `\\\nuniform tiltShiftUniforms {\n  float blurRadius;\n  float gradientRadius;\n  vec2 start;\n  vec2 end;\n  bool invert;\n} tiltShift;\n\nvec2 tiltShift_getDelta(vec2 texSize) {\n  vec2 vector = normalize((tiltShift.end - tiltShift.start) * texSize);\n  return tiltShift.invert ? vec2(-vector.y, vector.x) : vector;\n}\n\nvec4 tiltShift_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  vec2 normal = normalize(vec2((tiltShift.start.y - tiltShift.end.y) * texSize.y, (tiltShift.end.x - tiltShift.start.x) * texSize.x));\n  float radius = smoothstep(0.0, 1.0,\n    abs(dot(texCoord * texSize - tiltShift.start * texSize, normal)) / tiltShift.gradientRadius) * tiltShift.blurRadius;\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec4 offsetColor = texture(source, texCoord + tiltShift_getDelta(texSize) / texSize * percent * radius);\n\n    /* switch to pre-multiplied alpha to correctly blur transparent images */\n    offsetColor.rgb *= offsetColor.a;\n\n    color += offsetColor * weight;\n    total += weight;\n  }\n\n  color = color / total;\n\n  /* switch back from pre-multiplied alpha */\n  color.rgb /= color.a + 0.00001;\n\n  return color;\n}\n`;\n/**\n * Tilt Shift\n * Simulates the shallow depth of field normally encountered in close-up\n * photography, which makes the scene seem much smaller than it actually\n * is. This filter assumes the scene is relatively planar, in which case\n * the part of the scene that is completely in focus can be described by\n * a line (the intersection of the focal plane and the scene). An example\n * of a planar scene might be looking at a road from above at a downward\n * angle. The image is then blurred with a blur radius that starts at zero\n * on the line and increases further from the line.\n */\nexport const tiltShift = {\n    props: {},\n    uniforms: {},\n    name: 'tiltShift',\n    dependencies: [random],\n    uniformTypes: {\n        blurRadius: 'f32',\n        gradientRadius: 'f32',\n        start: 'vec2<f32>',\n        end: 'vec2<f32>',\n        invert: 'i32'\n    },\n    uniformPropTypes: {\n        blurRadius: { value: 15, min: 0, max: 50 },\n        gradientRadius: { value: 200, min: 0, max: 400 },\n        start: { value: [0, 0] },\n        end: { value: [1, 1] },\n        invert: { value: false, private: true }\n    },\n    passes: [\n        { sampler: true, uniforms: { invert: false } },\n        { sampler: true, uniforms: { invert: true } }\n    ],\n    fs\n};\n/*\nfunction tiltShift(startX, startY, endX, endY, blurRadius, gradientRadius) {\n  var dx = endX - startX;\n  var dy = endY - startY;\n  var d = Math.sqrt(dx * dx + dy * dy);\n  simpleShader.call(this, gl.tiltShift, {\n    blurRadius: blurRadius,\n    gradientRadius: gradientRadius,\n    start: [startX, startY],\n    end: [endX, endY],\n    delta: [dx / d, dy / d],\n    texSize: [this.width, this.height]\n  });\n  simpleShader.call(this, gl.tiltShift, {\n    blurRadius: blurRadius,\n    gradientRadius: gradientRadius,\n    start: [startX, startY],\n    end: [endX, endY],\n    delta: [-dy / d, dx / d],\n    texSize: [this.width, this.height]\n  });\n\n  return this;\n}\n*/\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { random } from \"../..//math/random/random.js\";\nconst fs = /* glsl */ `\\\nuniform triangleBlurUniforms {\n  float radius;\n  vec2 delta;\n} triangleBlur;\n\nvec4 triangleBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 adjustedDelta = triangleBlur.delta * triangleBlur.radius / texSize;\n\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec4 offsetColor = texture(source, texCoord + adjustedDelta * percent);\n\n    /* switch to pre-multiplied alpha to correctly blur transparent images */\n    offsetColor.rgb *= offsetColor.a;\n\n    color += offsetColor * weight;\n    total += weight;\n  }\n\n  color = color / total;\n\n  /* switch back from pre-multiplied alpha */\n  color.rgb /= color.a + 0.00001;\n\n  return color;\n}\n`;\n/**\n * @filter       Triangle Blur\n * @description  This is the most basic blur filter, which convolves the image with a\n *               pyramid filter. The pyramid filter is separable and is applied as two\n *               perpendicular triangle filters.\n */\nexport const triangleBlur = {\n    props: {},\n    uniforms: {},\n    name: 'triangleBlur',\n    uniformTypes: {\n        radius: 'f32',\n        delta: 'vec2<f32>'\n    },\n    uniformPropTypes: {\n        radius: { value: 20, min: 0, softMax: 100 },\n        delta: { value: [1, 0], private: true }\n    },\n    fs,\n    dependencies: [random],\n    passes: [\n        { sampler: true, uniforms: { delta: [1, 0] } },\n        { sampler: true, uniforms: { delta: [0, 1] } }\n    ]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { random } from \"../../math/random/random.js\";\nconst fs = `\nuniform zoomBlurUniforms {\n  vec2 center;\n  float strength;\n} zoomBlur;\n\nvec4 zoomBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n  vec2 toCenter = zoomBlur.center * texSize - texCoord * texSize;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = 0.0; t <= 40.0; t++) {\n    float percent = (t + offset) / 40.0;\n    float weight = 4.0 * (percent - percent * percent);\n    vec4 offsetColor = texture(source, texCoord + toCenter * percent * zoomBlur.strength / texSize);\n\n    /* switch to pre-multiplied alpha to correctly blur transparent images */\n    offsetColor.rgb *= offsetColor.a;\n\n    color += offsetColor * weight;\n    total += weight;\n  }\n\n  color = color / total;\n\n  /* switch back from pre-multiplied alpha */\n  color.rgb /= color.a + 0.00001;\n\n  return color;\n}\n`;\n/**\n * Zoom Blur\n * Blurs the image away from a certain point, which looks like radial motion blur.\n */\nexport const zoomBlur = {\n    props: {},\n    uniforms: {},\n    name: 'zoomBlur',\n    uniformTypes: {\n        center: 'vec2<f32>',\n        strength: 'f32'\n    },\n    uniformPropTypes: {\n        center: { value: [0.5, 0.5] },\n        strength: { value: 0.3, min: 0, softMax: 1 }\n    },\n    fs,\n    dependencies: [random],\n    passes: [{ sampler: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// TODO pass texCoord to angle\nconst fs = /* glsl */ `\\\nuniform colorHalftoneUniforms {\n  vec2 center;\n  float angle;\n  float size;\n} colorHalftone;\n\nfloat pattern(float angle, float scale, vec2 texSize, vec2 texCoord) {\n  float s = sin(angle), c = cos(angle);\n  vec2 tex = texCoord * texSize - colorHalftone.center * texSize;\n  vec2 point = vec2(\n\tc * tex.x - s * tex.y,\n\ts * tex.x + c * tex.y\n  ) * scale;\n  return (sin(point.x) * sin(point.y)) * 4.0;\n}\n\nvec4 colorHalftone_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  float scale = 3.1514 / colorHalftone.size;\n  vec3 cmy = 1.0 - color.rgb;\n  float k = min(cmy.x, min(cmy.y, cmy.z));\n\n  cmy = (cmy - k) / (1.0 - k);\n  cmy = clamp(\n\t  cmy * 10.0 - 3.0 + vec3(\n      pattern(colorHalftone.angle + 0.26179, scale, texSize, texCoord),\n\t    pattern(colorHalftone.angle + 1.30899, scale, texSize, texCoord),\n      pattern(colorHalftone.angle, scale, texSize, texCoord)\n    ),\n\t  0.0,\n\t  1.0\n  );\n  k = clamp(k * 10.0 - 5.0 + pattern(colorHalftone.angle + 0.78539, scale, texSize, texCoord), 0.0, 1.0);\n  return vec4(1.0 - cmy - k, color.a);\n}\n`;\n/**\n * Color Halftone -\n * Simulates a CMYK halftone rendering of the image by multiplying pixel values\n * with a four rotated 2D sine wave patterns, one each for cyan, magenta, yellow,\n * and black.\n */\nexport const colorHalftone = {\n    props: {},\n    uniforms: {},\n    name: 'colorHalftone',\n    uniformTypes: {\n        center: 'vec2<f32>',\n        angle: 'f32',\n        size: 'f32'\n    },\n    uniformPropTypes: {\n        center: { value: [0.5, 0.5] },\n        angle: { value: 1.1, softMin: 0, softMax: Math.PI / 2 },\n        size: { value: 4, min: 1, softMin: 3, softMax: 20 }\n    },\n    fs,\n    passes: [{ filter: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nuniform dotScreenUniforms {\n  vec2 center;\n  float angle;\n  float size;\n} dotScreen;\n\nfloat pattern(vec2 texSize, vec2 texCoord) {\n  float scale = 3.1415 / dotScreen.size;\n\n  float s = sin(dotScreen.angle), c = cos(dotScreen.angle);\n  vec2 tex = texCoord * texSize - dotScreen.center * texSize;\n  vec2 point = vec2(\n    c * tex.x - s * tex.y,\n    s * tex.x + c * tex.y\n  ) * scale;\n  return (sin(point.x) * sin(point.y)) * 4.0;\n}\n\nvec4 dotScreen_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  float average = (color.r + color.g + color.b) / 3.0;\n  return vec4(vec3(average * 10.0 - 5.0 + pattern(texSize, texCoord)), color.a);\n}\n`;\n/**\n * Dot Screen -\n * Simulates a black and white halftone rendering of the image by multiplying\n * pixel values with a rotated 2D sine wave pattern.\n */\nexport const dotScreen = {\n    props: {},\n    uniforms: {},\n    name: 'dotScreen',\n    uniformTypes: {\n        center: 'vec2<f32>',\n        angle: 'f32',\n        size: 'f32'\n    },\n    uniformPropTypes: {\n        center: { value: [0.5, 0.5] },\n        angle: { value: 1.1, softMin: 0, softMax: Math.PI / 2 },\n        size: { value: 3, min: 1, softMin: 3, softMax: 20 }\n    },\n    fs,\n    passes: [{ filter: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { random } from \"../../math/random/random.js\";\nconst fs = /* glsl */ `\\\nuniform edgeWorkUniforms {\n  float radius;\n  vec2 delta;\n} edgeWork;\n\nvec4 edgeWork_sampleColor1(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;\n\n  vec2 color = vec2(0.0);\n  vec2 total = vec2(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec3 sampleColor = texture(source, texCoord + relativeDelta * percent).rgb;\n    float average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;\n    color.x += average * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += average * weight;\n      total.y += weight;\n    }\n  }\n  return vec4(color / total, 0.0, 1.0);\n}\n\nvec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;\n\n  vec2 color = vec2(0.0);\n  vec2 total = vec2(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec2 sampleColor = texture(source, texCoord + relativeDelta * percent).xy;\n    color.x += sampleColor.x * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += sampleColor.y * weight;\n      total.y += weight;\n    }\n  }\n  float c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);\n  return vec4(c, c, c, 1.0);\n}\n`;\n/**\n * Edge Work -\n * Picks out different frequencies in the image by subtracting two\n * copies of the image blurred with different radii.\n */\nexport const edgeWork = {\n    props: {},\n    uniforms: {},\n    name: 'edgeWork',\n    dependencies: [random],\n    fs,\n    uniformPropTypes: {\n        radius: { value: 2, min: 1, softMax: 50 },\n        delta: { value: [1, 0], private: true }\n    },\n    passes: [\n        {\n            // @ts-expect-error\n            sampler: 'edgeWork_sampleColor1',\n            uniformPropTypes: { delta: [1, 0] }\n        },\n        {\n            // @ts-expect-error\n            sampler: 'edgeWork_sampleColor2',\n            uniformPropTypes: { delta: [0, 1] }\n        }\n    ]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nuniform hexagonalPixelateUniforms {\n  vec2 center;\n  float scale;\n} hexagonalPixelate;\n\nvec4 hexagonalPixelate_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 tex = (texCoord * texSize - hexagonalPixelate.center * texSize) / hexagonalPixelate.scale;\n  tex.y /= 0.866025404;\n  tex.x -= tex.y * 0.5;\n\n  vec2 a;\n  if (tex.x + tex.y - floor(tex.x) - floor(tex.y) < 1.0) {\n    a = vec2(floor(tex.x), floor(tex.y));\n  }\n  else a = vec2(ceil(tex.x), ceil(tex.y));\n  vec2 b = vec2(ceil(tex.x), floor(tex.y));\n  vec2 c = vec2(floor(tex.x), ceil(tex.y));\n\n  vec3 TEX = vec3(tex.x, tex.y, 1.0 - tex.x - tex.y);\n  vec3 A = vec3(a.x, a.y, 1.0 - a.x - a.y);\n  vec3 B = vec3(b.x, b.y, 1.0 - b.x - b.y);\n  vec3 C = vec3(c.x, c.y, 1.0 - c.x - c.y);\n\n  float alen = length(TEX - A);\n  float blen = length(TEX - B);\n  float clen = length(TEX - C);\n\n  vec2 choice;\n  if (alen < blen) {\n    if (alen < clen) choice = a;\n    else choice = c;\n  } else {\n    if (blen < clen) choice = b;\n    else choice = c;\n  }\n\n  choice.x += choice.y * 0.5;\n  choice.y *= 0.866025404;\n  choice *= hexagonalPixelate.scale / texSize;\n\n  return texture(source, choice + hexagonalPixelate.center);\n}\n`;\n/**\n * Hexagonal Pixelate\n * Renders the image using a pattern of hexagonal tiles. Tile colors\n * are nearest-neighbor sampled from the centers of the tiles.\n */\nexport const hexagonalPixelate = {\n    props: {},\n    uniforms: {},\n    name: 'hexagonalPixelate',\n    uniformTypes: {\n        center: 'vec2<f32>',\n        scale: 'f32'\n    },\n    uniformPropTypes: {\n        center: { value: [0.5, 0.5], hint: 'screenspace' },\n        scale: { value: 10, min: 1, softMin: 5, softMax: 50 }\n    },\n    fs,\n    passes: [{ sampler: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nuniform inkUniforms {\n  float strength;\n} ink;\n\nvec4 ink_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 dx = vec2(1.0 / texSize.x, 0.0);\n  vec2 dy = vec2(0.0, 1.0 / texSize.y);\n  vec4 color = texture(source, texCoord);\n  float bigTotal = 0.0;\n  float smallTotal = 0.0;\n  vec3 bigAverage = vec3(0.0);\n  vec3 smallAverage = vec3(0.0);\n  for (float x = -2.0; x <= 2.0; x += 1.0) {\n    for (float y = -2.0; y <= 2.0; y += 1.0) {\n      vec3 offsetColor = texture(source, texCoord + dx * x + dy * y).rgb;\n      bigAverage += offsetColor;\n      bigTotal += 1.0;\n      if (abs(x) + abs(y) < 2.0) {\n        smallAverage += offsetColor;\n        smallTotal += 1.0;\n      }\n    }\n  }\n  vec3 edge = max(vec3(0.0), bigAverage / bigTotal - smallAverage / smallTotal);\n  float power = ink.strength * ink.strength * ink.strength * ink.strength * ink.strength;\n  return vec4(color.rgb - dot(edge, edge) * power * 100000.0, color.a);\n}\n`;\n/**\n * Ink -\n * Simulates outlining the image in ink by darkening edges stronger than a\n * certain threshold. The edge detection value is the difference of two\n * copies of the image, each blurred using a blur of a different radius.\n */\nexport const ink = {\n    props: {},\n    uniforms: {},\n    name: 'ink',\n    fs,\n    uniformTypes: {\n        strength: 'f32'\n    },\n    uniformPropTypes: {\n        strength: { value: 0.25, min: 0, softMax: 1 }\n    },\n    passes: [{ sampler: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nuniform magnifyUniforms {\n  vec2 screenXY;\n  float radiusPixels;\n  float zoom;\n  float borderWidthPixels;\n  vec4 borderColor;\n} magnify;\n\nvec4 magnify_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 pos = vec2(magnify.screenXY.x, 1.0 - magnify.screenXY.y);\n  float dist = distance(texCoord * texSize, pos * texSize);\n  if (dist < magnify.radiusPixels) {\n    return texture(source, (texCoord - pos) / magnify.zoom + pos);\n  }\n\n  if (dist <= magnify.radiusPixels + magnify.borderWidthPixels) {\n    return magnify.borderColor;\n  }\n  return texture(source, texCoord);\n}\n`;\n/**\n * Magnify - display a circle with magnify effect applied to surrounding the pixels given position\n */\nexport const magnify = {\n    name: 'magnify',\n    uniformTypes: {\n        screenXY: 'vec2<f32>',\n        radiusPixels: 'f32',\n        zoom: 'f32',\n        borderWidthPixels: 'f32',\n        borderColor: 'vec4<f32>'\n    },\n    uniformPropTypes: {\n        // range 0 to 1\n        screenXY: { value: [0, 0] },\n        radiusPixels: 200,\n        zoom: 2.0,\n        borderWidthPixels: 0.0,\n        borderColor: { value: [255, 255, 255, 255] }\n    },\n    fs,\n    passes: [{ sampler: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst fs = /* glsl */ `\\\nvec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {\n  vec4 color = texture(source, coord / texSize);\n  vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);\n  if (coord != clampedCoord) {\n    /* fade to transparent if we are outside the image */\n    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));\n  }\n\n  return color;\n}\n`;\nexport const warp = {\n    name: 'warp',\n    passes: [],\n    fs\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { warp } from \"./warp.js\";\nconst fs = /* glsl */ `\\\nuniform bulgePinchUniforms {\n  float radius;\n  float strength;\n  vec2 center;\n} bulgePinch;\n\nvec2 bulgePinch_warp(vec2 coord, vec2 texCenter) {\n  coord -= texCenter;\n  float distance = length(coord);\n  if (distance < bulgePinch.radius) {\n    float percent = distance / bulgePinch.radius;\n    if (bulgePinch.strength > 0.0) {\n      coord *= mix(1.0, smoothstep(0.0, bulgePinch.radius / distance, percent), bulgePinch.strength * 0.75);\n    } else {\n      coord *= mix(1.0, pow(percent, 1.0 + bulgePinch.strength * 0.75) * bulgePinch.radius / distance, 1.0 - percent);\n    }\n  }\n  coord += texCenter;\n  return coord;\n}\n\nvec4 bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 coord = texCoord * texSize;\n  coord = bulgePinch_warp(coord, bulgePinch.center * texSize);\n\n  return warp_sampleColor(source, texSize, coord);\n}\n`;\n/**\n * Bulge / Pinch -\n * Bulges or pinches the image in a circle.\n */\nexport const bulgePinch = {\n    props: {},\n    uniforms: {},\n    name: 'bulgePinch',\n    dependencies: [warp],\n    fs,\n    uniformTypes: {\n        center: 'vec2<f32>',\n        radius: 'f32',\n        strength: 'f32'\n    },\n    uniformPropTypes: {\n        center: { value: [0.5, 0.5] },\n        radius: { value: 200, min: 1, softMax: 600 },\n        strength: { value: 0.5, min: -1, max: 1 }\n    },\n    passes: [{ sampler: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { warp } from \"./warp.js\";\nconst fs = /* glsl */ `\\\nuniform swirlUniforms {\n  float radius;\n  float angle;\n  vec2 center;\n} swirl;\n\nvec2 swirl_warp(vec2 coord, vec2 texCenter) {\n  coord -= texCenter;\n  float distance = length(coord);\n  if (distance < swirl.radius) {\n    float percent = (swirl.radius - distance) / swirl.radius;\n    float theta = percent * percent * swirl.angle;\n    float s = sin(theta);\n    float c = cos(theta);\n    coord = vec2(\n      coord.x * c - coord.y * s,\n      coord.x * s + coord.y * c\n    );\n  }\n  coord += texCenter;\n  return coord;\n}\n\nvec4 swirl_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 coord = texCoord * texSize;\n  coord = swirl_warp(coord, swirl.center * texSize);\n\n  return warp_sampleColor(source, texSize, coord);\n}\n`;\n/**\n * Warps a circular region of the image in a swirl.\n */\nexport const swirl = {\n    props: {},\n    uniforms: {},\n    name: 'swirl',\n    dependencies: [warp],\n    fs,\n    uniformTypes: {\n        center: 'vec2<f32>',\n        radius: 'f32',\n        angle: 'f32'\n    },\n    uniformPropTypes: {\n        center: { value: [0.5, 0.5] },\n        radius: { value: 200, min: 1, softMax: 600 },\n        angle: { value: 3, softMin: -25, softMax: 25 }\n    },\n    passes: [{ sampler: true }]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/**\n * ORIGINAL LICENCE\n * @license\n * Copyright (c) 2014-2015, NVIDIA CORPORATION. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions\n * are met:\n *  * Redistributions of source code must retain the above copyright\n *    notice, this list of conditions and the following disclaimer.\n *  * Redistributions in binary form must reproduce the above copyright\n *    notice, this list of conditions and the following disclaimer in the\n *    documentation and/or other materials provided with the distribution.\n *  * Neither the name of NVIDIA CORPORATION nor the names of its\n *    contributors may be used to endorse or promote products derived\n *    from this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY\n * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR\n * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\n * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY\n * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n// LUMA.GL\n// WebGL version from cesium.js, used under Apached 2.0 License\n// https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n// with the following modifications:\n// - fxaa_sampleColor to integrate with luma.gl\n// - Return color value with alpha to avoid another tap\n// - Calculate luminance in FxaaLuma\n// COMMENTS FROM CESIUM VERSION\n// NVIDIA GameWorks Graphics Samples GitHub link: https://github.com/NVIDIAGameWorks/GraphicsSamples\n// Original FXAA 3.11 shader link: https://github.com/NVIDIAGameWorks/GraphicsSamples/blob/master/samples/es3-kepler/FXAA/FXAA3_11.h\n//\n// Steps used to integrate into Cesium:\n// * The following defines are set:\n//       #define FXAA_PC 1\n//       #define FXAA_WEBGL_1 1\n//       #define FXAA_GREEN_AS_LUMA 1\n//       #define FXAA_EARLY_EXIT 1\n//       #define FXAA_GLSL_120 1\n// * All other preprocessor directives besides the FXAA_QUALITY__P* directives were removed.\n// * Double underscores are invalid for preprocessor directives so replace them with a single underscore. Replace\n//   /FXAA_QUALITY__P(.*)/g with /FXAA_QUALITY__P$1/.\n// * There are no implicit conversions from ivec* to vec* so replace:\n//       #define FxaaInt2 ivec2\n//           with\n//       #define FxaaInt2 vec2\n// * The texture2DLod function is only available in vertex shaders so replace:\n//       #define FxaaTexTop(t, p) texture2DLod(t, p, 0.0)\n//       #define FxaaTexOff(t, p, o, r) texture2DLod(t, p + (o * r), 0.0)\n//           with\n//       #define FxaaTexTop(t, p) texture2D(t, p)\n//       #define FxaaTexOff(t, p, o, r) texture2D(t, p + (o * r))\n// * FXAA_QUALITY_PRESET is prepended in the javascript code. We may want to expose that setting in the future.\n// * The following parameters to FxaaPixelShader_ are unused and can be removed:\n//       fxaaConsolePosPos\n//       fxaaConsoleRcpFrameOpt\n//       fxaaConsoleRcpFrameOpt2\n//       fxaaConsole360RcpFrameOpt2\n//       fxaaConsoleEdgeSharpness\n//       fxaaConsoleEdgeThreshold\n//       fxaaConsoleEdgeThresholdMi\n//       fxaaConsole360ConstDir\n//\n// Choose the quality preset.\n// This needs to be compiled into the shader as it effects code.\n// Best option to include multiple presets is to\n// in each shader define the preset, then include this file.\n//\n// OPTIONS\n// -----------------------------------------------------------------------\n// 10 to 15 - default medium dither (10=fastest, 15=highest quality)\n// 20 to 29 - less dither, more expensive (20=fastest, 29=highest quality)\n// 39       - no dither, very expensive\n//\n// NOTES\n// -----------------------------------------------------------------------\n// 12 = slightly faster then FXAA 3.9 and higher edge quality (default)\n// 13 = about same speed as FXAA 3.9 and better than 12\n// 23 = closest to FXAA 3.9 visually and performance wise\n//  _ = the lowest digit is directly related to performance\n// _  = the highest digit is directly related to style\n//\nconst fs = `\n#define FXAA_QUALITY_PRESET 29\n\n#if (FXAA_QUALITY_PRESET == 10)\n    #define FXAA_QUALITY_PS 3\n    #define FXAA_QUALITY_P0 1.5\n    #define FXAA_QUALITY_P1 3.0\n    #define FXAA_QUALITY_P2 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 11)\n    #define FXAA_QUALITY_PS 4\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 3.0\n    #define FXAA_QUALITY_P3 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 12)\n    #define FXAA_QUALITY_PS 5\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 4.0\n    #define FXAA_QUALITY_P4 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 13)\n    #define FXAA_QUALITY_PS 6\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 4.0\n    #define FXAA_QUALITY_P5 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 14)\n    #define FXAA_QUALITY_PS 7\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 4.0\n    #define FXAA_QUALITY_P6 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 15)\n    #define FXAA_QUALITY_PS 8\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 4.0\n    #define FXAA_QUALITY_P7 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 20)\n    #define FXAA_QUALITY_PS 3\n    #define FXAA_QUALITY_P0 1.5\n    #define FXAA_QUALITY_P1 2.0\n    #define FXAA_QUALITY_P2 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 21)\n    #define FXAA_QUALITY_PS 4\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 22)\n    #define FXAA_QUALITY_PS 5\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 23)\n    #define FXAA_QUALITY_PS 6\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 24)\n    #define FXAA_QUALITY_PS 7\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 3.0\n    #define FXAA_QUALITY_P6 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 25)\n    #define FXAA_QUALITY_PS 8\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 4.0\n    #define FXAA_QUALITY_P7 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 26)\n    #define FXAA_QUALITY_PS 9\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 4.0\n    #define FXAA_QUALITY_P8 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 27)\n    #define FXAA_QUALITY_PS 10\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 2.0\n    #define FXAA_QUALITY_P8 4.0\n    #define FXAA_QUALITY_P9 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 28)\n    #define FXAA_QUALITY_PS 11\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 2.0\n    #define FXAA_QUALITY_P8 2.0\n    #define FXAA_QUALITY_P9 4.0\n    #define FXAA_QUALITY_P10 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 29)\n    #define FXAA_QUALITY_PS 12\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 2.0\n    #define FXAA_QUALITY_P8 2.0\n    #define FXAA_QUALITY_P9 2.0\n    #define FXAA_QUALITY_P10 4.0\n    #define FXAA_QUALITY_P11 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 39)\n    #define FXAA_QUALITY_PS 12\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.0\n    #define FXAA_QUALITY_P2 1.0\n    #define FXAA_QUALITY_P3 1.0\n    #define FXAA_QUALITY_P4 1.0\n    #define FXAA_QUALITY_P5 1.5\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 2.0\n    #define FXAA_QUALITY_P8 2.0\n    #define FXAA_QUALITY_P9 2.0\n    #define FXAA_QUALITY_P10 4.0\n    #define FXAA_QUALITY_P11 8.0\n#endif\n\n#define FxaaBool bool\n#define FxaaFloat float\n#define FxaaFloat2 vec2\n#define FxaaFloat3 vec3\n#define FxaaFloat4 vec4\n#define FxaaHalf float\n#define FxaaHalf2 vec2\n#define FxaaHalf3 vec3\n#define FxaaHalf4 vec4\n#define FxaaInt2 vec2\n#define FxaaTex sampler2D\n\n#define FxaaSat(x) clamp(x, 0.0, 1.0)\n#define FxaaTexTop(t, p) texture(t, p)\n#define FxaaTexOff(t, p, o, r) texture(t, p + (o * r))\n\nFxaaFloat FxaaLuma_(FxaaFloat4 rgba) { return dot(rgba.rgb, vec3(0.2126, 0.7152, 0.0722)); }\n\nFxaaFloat4 FxaaPixelShader_(\n    //\n    // Use noperspective interpolation here (turn off perspective interpolation).\n    // {xy} = center of pixel\n    FxaaFloat2 pos,\n    //\n    // Input color texture.\n    // {rgb_} = color in linear or perceptual color space\n    // if (FXAA_GREEN_AS_LUMA == 0)\n    //     {___a} = luma in perceptual color space (not linear)\n    FxaaTex tex,\n    //\n    // Only used on FXAA Quality.\n    // This must be from a constant/uniform.\n    // {x_} = 1.0/screenWidthInPixels\n    // {_y} = 1.0/screenHeightInPixels\n    FxaaFloat2 fxaaQualityRcpFrame,\n    //\n    // Only used on FXAA Quality.\n    // This used to be the FXAA_QUALITY_SUBPIX define.\n    // It is here now to allow easier tuning.\n    // Choose the amount of sub-pixel aliasing removal.\n    // This can effect sharpness.\n    //   1.00 - upper limit (softer)\n    //   0.75 - default amount of filtering\n    //   0.50 - lower limit (sharper, less sub-pixel aliasing removal)\n    //   0.25 - almost off\n    //   0.00 - completely off\n    FxaaFloat fxaaQualitySubpix,\n    //\n    // Only used on FXAA Quality.\n    // This used to be the FXAA_QUALITY_EDGE_THRESHOLD define.\n    // It is here now to allow easier tuning.\n    // The minimum amount of local contrast required to apply algorithm.\n    //   0.333 - too little (faster)\n    //   0.250 - low quality\n    //   0.166 - default\n    //   0.125 - high quality\n    //   0.063 - overkill (slower)\n    FxaaFloat fxaaQualityEdgeThreshold,\n    //\n    // Only used on FXAA Quality.\n    // This used to be the FXAA_QUALITY_EDGE_THRESHOLD_MIN define.\n    // It is here now to allow easier tuning.\n    // Trims the algorithm from processing darks.\n    //   0.0833 - upper limit (default, the start of visible unfiltered edges)\n    //   0.0625 - high quality (faster)\n    //   0.0312 - visible limit (slower)\n    // Special notes when using FXAA_GREEN_AS_LUMA,\n    //   Likely want to set this to zero.\n    //   As colors that are mostly not-green\n    //   will appear very dark in the green channel!\n    //   Tune by looking at mostly non-green content,\n    //   then start at zero and increase until aliasing is a problem.\n    FxaaFloat fxaaQualityEdgeThresholdMin\n) {\n/*--------------------------------------------------------------------------*/\n    FxaaFloat2 posM;\n    posM.x = pos.x;\n    posM.y = pos.y;\n    FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);\n    #define lumaM rgbyM.y\n    FxaaFloat lumaS = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 0, 1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaE = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 1, 0), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaN = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 0,-1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaW = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2(-1, 0), fxaaQualityRcpFrame.xy));\n/*--------------------------------------------------------------------------*/\n    FxaaFloat maxSM = max(lumaS, lumaM);\n    FxaaFloat minSM = min(lumaS, lumaM);\n    FxaaFloat maxESM = max(lumaE, maxSM);\n    FxaaFloat minESM = min(lumaE, minSM);\n    FxaaFloat maxWN = max(lumaN, lumaW);\n    FxaaFloat minWN = min(lumaN, lumaW);\n    FxaaFloat rangeMax = max(maxWN, maxESM);\n    FxaaFloat rangeMin = min(minWN, minESM);\n    FxaaFloat rangeMaxScaled = rangeMax * fxaaQualityEdgeThreshold;\n    FxaaFloat range = rangeMax - rangeMin;\n    FxaaFloat rangeMaxClamped = max(fxaaQualityEdgeThresholdMin, rangeMaxScaled);\n    FxaaBool earlyExit = range < rangeMaxClamped;\n/*--------------------------------------------------------------------------*/\n    if(earlyExit)\n        return rgbyM;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat lumaNW = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2(-1,-1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaSE = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 1, 1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaNE = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 1,-1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaSW = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));\n/*--------------------------------------------------------------------------*/\n    FxaaFloat lumaNS = lumaN + lumaS;\n    FxaaFloat lumaWE = lumaW + lumaE;\n    FxaaFloat subpixRcpRange = 1.0/range;\n    FxaaFloat subpixNSWE = lumaNS + lumaWE;\n    FxaaFloat edgeHorz1 = (-2.0 * lumaM) + lumaNS;\n    FxaaFloat edgeVert1 = (-2.0 * lumaM) + lumaWE;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat lumaNESE = lumaNE + lumaSE;\n    FxaaFloat lumaNWNE = lumaNW + lumaNE;\n    FxaaFloat edgeHorz2 = (-2.0 * lumaE) + lumaNESE;\n    FxaaFloat edgeVert2 = (-2.0 * lumaN) + lumaNWNE;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat lumaNWSW = lumaNW + lumaSW;\n    FxaaFloat lumaSWSE = lumaSW + lumaSE;\n    FxaaFloat edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);\n    FxaaFloat edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);\n    FxaaFloat edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;\n    FxaaFloat edgeVert3 = (-2.0 * lumaS) + lumaSWSE;\n    FxaaFloat edgeHorz = abs(edgeHorz3) + edgeHorz4;\n    FxaaFloat edgeVert = abs(edgeVert3) + edgeVert4;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat subpixNWSWNESE = lumaNWSW + lumaNESE;\n    FxaaFloat lengthSign = fxaaQualityRcpFrame.x;\n    FxaaBool horzSpan = edgeHorz >= edgeVert;\n    FxaaFloat subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;\n/*--------------------------------------------------------------------------*/\n    if(!horzSpan) lumaN = lumaW;\n    if(!horzSpan) lumaS = lumaE;\n    if(horzSpan) lengthSign = fxaaQualityRcpFrame.y;\n    FxaaFloat subpixB = (subpixA * (1.0/12.0)) - lumaM;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat gradientN = lumaN - lumaM;\n    FxaaFloat gradientS = lumaS - lumaM;\n    FxaaFloat lumaNN = lumaN + lumaM;\n    FxaaFloat lumaSS = lumaS + lumaM;\n    FxaaBool pairN = abs(gradientN) >= abs(gradientS);\n    FxaaFloat gradient = max(abs(gradientN), abs(gradientS));\n    if(pairN) lengthSign = -lengthSign;\n    FxaaFloat subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);\n/*--------------------------------------------------------------------------*/\n    FxaaFloat2 posB;\n    posB.x = posM.x;\n    posB.y = posM.y;\n    FxaaFloat2 offNP;\n    offNP.x = (!horzSpan) ? 0.0 : fxaaQualityRcpFrame.x;\n    offNP.y = ( horzSpan) ? 0.0 : fxaaQualityRcpFrame.y;\n    if(!horzSpan) posB.x += lengthSign * 0.5;\n    if( horzSpan) posB.y += lengthSign * 0.5;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat2 posN;\n    posN.x = posB.x - offNP.x * FXAA_QUALITY_P0;\n    posN.y = posB.y - offNP.y * FXAA_QUALITY_P0;\n    FxaaFloat2 posP;\n    posP.x = posB.x + offNP.x * FXAA_QUALITY_P0;\n    posP.y = posB.y + offNP.y * FXAA_QUALITY_P0;\n    FxaaFloat subpixD = ((-2.0)*subpixC) + 3.0;\n    FxaaFloat lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN));\n    FxaaFloat subpixE = subpixC * subpixC;\n    FxaaFloat lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP));\n/*--------------------------------------------------------------------------*/\n    if(!pairN) lumaNN = lumaSS;\n    FxaaFloat gradientScaled = gradient * 1.0/4.0;\n    FxaaFloat lumaMM = lumaM - lumaNN * 0.5;\n    FxaaFloat subpixF = subpixD * subpixE;\n    FxaaBool lumaMLTZero = lumaMM < 0.0;\n/*--------------------------------------------------------------------------*/\n    lumaEndN -= lumaNN * 0.5;\n    lumaEndP -= lumaNN * 0.5;\n    FxaaBool doneN = abs(lumaEndN) >= gradientScaled;\n    FxaaBool doneP = abs(lumaEndP) >= gradientScaled;\n    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P1;\n    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P1;\n    FxaaBool doneNP = (!doneN) || (!doneP);\n    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P1;\n    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P1;\n/*--------------------------------------------------------------------------*/\n    if(doneNP) {\n        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n        doneN = abs(lumaEndN) >= gradientScaled;\n        doneP = abs(lumaEndP) >= gradientScaled;\n        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P2;\n        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P2;\n        doneNP = (!doneN) || (!doneP);\n        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P2;\n        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P2;\n/*--------------------------------------------------------------------------*/\n        #if (FXAA_QUALITY_PS > 3)\n        if(doneNP) {\n            if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n            if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n            doneN = abs(lumaEndN) >= gradientScaled;\n            doneP = abs(lumaEndP) >= gradientScaled;\n            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P3;\n            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P3;\n            doneNP = (!doneN) || (!doneP);\n            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P3;\n            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P3;\n/*--------------------------------------------------------------------------*/\n            #if (FXAA_QUALITY_PS > 4)\n            if(doneNP) {\n                if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                doneN = abs(lumaEndN) >= gradientScaled;\n                doneP = abs(lumaEndP) >= gradientScaled;\n                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P4;\n                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P4;\n                doneNP = (!doneN) || (!doneP);\n                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P4;\n                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P4;\n/*--------------------------------------------------------------------------*/\n                #if (FXAA_QUALITY_PS > 5)\n                if(doneNP) {\n                    if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                    if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                    doneN = abs(lumaEndN) >= gradientScaled;\n                    doneP = abs(lumaEndP) >= gradientScaled;\n                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P5;\n                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P5;\n                    doneNP = (!doneN) || (!doneP);\n                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P5;\n                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P5;\n/*--------------------------------------------------------------------------*/\n                    #if (FXAA_QUALITY_PS > 6)\n                    if(doneNP) {\n                        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                        doneN = abs(lumaEndN) >= gradientScaled;\n                        doneP = abs(lumaEndP) >= gradientScaled;\n                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P6;\n                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P6;\n                        doneNP = (!doneN) || (!doneP);\n                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P6;\n                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P6;\n/*--------------------------------------------------------------------------*/\n                        #if (FXAA_QUALITY_PS > 7)\n                        if(doneNP) {\n                            if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                            if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                            doneN = abs(lumaEndN) >= gradientScaled;\n                            doneP = abs(lumaEndP) >= gradientScaled;\n                            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P7;\n                            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P7;\n                            doneNP = (!doneN) || (!doneP);\n                            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P7;\n                            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P7;\n/*--------------------------------------------------------------------------*/\n    #if (FXAA_QUALITY_PS > 8)\n    if(doneNP) {\n        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n        doneN = abs(lumaEndN) >= gradientScaled;\n        doneP = abs(lumaEndP) >= gradientScaled;\n        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P8;\n        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P8;\n        doneNP = (!doneN) || (!doneP);\n        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P8;\n        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P8;\n/*--------------------------------------------------------------------------*/\n        #if (FXAA_QUALITY_PS > 9)\n        if(doneNP) {\n            if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n            if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n            doneN = abs(lumaEndN) >= gradientScaled;\n            doneP = abs(lumaEndP) >= gradientScaled;\n            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P9;\n            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P9;\n            doneNP = (!doneN) || (!doneP);\n            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P9;\n            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P9;\n/*--------------------------------------------------------------------------*/\n            #if (FXAA_QUALITY_PS > 10)\n            if(doneNP) {\n                if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                doneN = abs(lumaEndN) >= gradientScaled;\n                doneP = abs(lumaEndP) >= gradientScaled;\n                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P10;\n                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P10;\n                doneNP = (!doneN) || (!doneP);\n                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P10;\n                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P10;\n/*--------------------------------------------------------------------------*/\n                #if (FXAA_QUALITY_PS > 11)\n                if(doneNP) {\n                    if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                    if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                    doneN = abs(lumaEndN) >= gradientScaled;\n                    doneP = abs(lumaEndP) >= gradientScaled;\n                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P11;\n                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P11;\n                    doneNP = (!doneN) || (!doneP);\n                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P11;\n                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P11;\n/*--------------------------------------------------------------------------*/\n                    #if (FXAA_QUALITY_PS > 12)\n                    if(doneNP) {\n                        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));\n                        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));\n                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                        doneN = abs(lumaEndN) >= gradientScaled;\n                        doneP = abs(lumaEndP) >= gradientScaled;\n                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P12;\n                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P12;\n                        doneNP = (!doneN) || (!doneP);\n                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P12;\n                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P12;\n/*--------------------------------------------------------------------------*/\n                    }\n                    #endif\n/*--------------------------------------------------------------------------*/\n                }\n                #endif\n/*--------------------------------------------------------------------------*/\n            }\n            #endif\n/*--------------------------------------------------------------------------*/\n        }\n        #endif\n/*--------------------------------------------------------------------------*/\n    }\n    #endif\n/*--------------------------------------------------------------------------*/\n                        }\n                        #endif\n/*--------------------------------------------------------------------------*/\n                    }\n                    #endif\n/*--------------------------------------------------------------------------*/\n                }\n                #endif\n/*--------------------------------------------------------------------------*/\n            }\n            #endif\n/*--------------------------------------------------------------------------*/\n        }\n        #endif\n/*--------------------------------------------------------------------------*/\n    }\n/*--------------------------------------------------------------------------*/\n    FxaaFloat dstN = posM.x - posN.x;\n    FxaaFloat dstP = posP.x - posM.x;\n    if(!horzSpan) dstN = posM.y - posN.y;\n    if(!horzSpan) dstP = posP.y - posM.y;\n/*--------------------------------------------------------------------------*/\n    FxaaBool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;\n    FxaaFloat spanLength = (dstP + dstN);\n    FxaaBool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;\n    FxaaFloat spanLengthRcp = 1.0/spanLength;\n/*--------------------------------------------------------------------------*/\n    FxaaBool directionN = dstN < dstP;\n    FxaaFloat dst = min(dstN, dstP);\n    FxaaBool goodSpan = directionN ? goodSpanN : goodSpanP;\n    FxaaFloat subpixG = subpixF * subpixF;\n    FxaaFloat pixelOffset = (dst * (-spanLengthRcp)) + 0.5;\n    FxaaFloat subpixH = subpixG * fxaaQualitySubpix;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat pixelOffsetGood = goodSpan ? pixelOffset : 0.0;\n    FxaaFloat pixelOffsetSubpix = max(pixelOffsetGood, subpixH);\n    if(!horzSpan) posM.x += pixelOffsetSubpix * lengthSign;\n    if( horzSpan) posM.y += pixelOffsetSubpix * lengthSign;\n    return FxaaTexTop(tex, posM);\n}\n\nvec4 fxaa_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n    const float fxaa_QualitySubpix = 0.5;\n    const float fxaa_QualityEdgeThreshold = 0.125;\n    const float fxaa_QualityEdgeThresholdMin = 0.0833;\n\n    return FxaaPixelShader_(\n        texCoord,\n        source,\n        vec2(1.0) / texSize,\n        fxaa_QualitySubpix,\n        fxaa_QualityEdgeThreshold,\n        fxaa_QualityEdgeThresholdMin\n    );\n}\n`;\n/**\n * FXAA - Fast Approximate Anti-aliasing.\n */\nexport const fxaa = {\n    name: 'fxaa',\n    uniformPropTypes: {},\n    fs,\n    passes: [{ sampler: true }],\n    getUniforms: props => props\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const fp64arithmeticShader = /* glsl */ `\\\nuniform float ONE;\n\n/*\nAbout LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n\nThe purpose of this workaround is to prevent shader compilers from\noptimizing away necessary arithmetic operations by swapping their sequences\nor transform the equation to some 'equivalent' form.\n\nThe method is to multiply an artifical variable, ONE, which will be known to\nthe compiler to be 1 only at runtime. The whole expression is then represented\nas a polynomial with respective to ONE. In the coefficients of all terms, only one a\nand one b should appear\n\nerr = (a + b) * ONE^6 - a * ONE^5 - (a + b) * ONE^4 + a * ONE^3 - b - (a + b) * ONE^2 + a * ONE\n*/\n\n// Divide float number to high and low floats to extend fraction bits\nvec2 split(float a) {\n  const float SPLIT = 4097.0;\n  float t = a * SPLIT;\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  float a_hi = t * ONE - (t - a);\n  float a_lo = a * ONE - a_hi;\n#else\n  float a_hi = t - (t - a);\n  float a_lo = a - a_hi;\n#endif\n  return vec2(a_hi, a_lo);\n}\n\n// Divide float number again when high float uses too many fraction bits\nvec2 split2(vec2 a) {\n  vec2 b = split(a.x);\n  b.y += a.y;\n  return b;\n}\n\n// Special sum operation when a > b\nvec2 quickTwoSum(float a, float b) {\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  float sum = (a + b) * ONE;\n  float err = b - (sum - a) * ONE;\n#else\n  float sum = a + b;\n  float err = b - (sum - a);\n#endif\n  return vec2(sum, err);\n}\n\n// General sum operation\nvec2 twoSum(float a, float b) {\n  float s = (a + b);\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  float v = (s * ONE - a) * ONE;\n  float err = (a - (s - v) * ONE) * ONE * ONE * ONE + (b - v);\n#else\n  float v = s - a;\n  float err = (a - (s - v)) + (b - v);\n#endif\n  return vec2(s, err);\n}\n\nvec2 twoSub(float a, float b) {\n  float s = (a - b);\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  float v = (s * ONE - a) * ONE;\n  float err = (a - (s - v) * ONE) * ONE * ONE * ONE - (b + v);\n#else\n  float v = s - a;\n  float err = (a - (s - v)) - (b + v);\n#endif\n  return vec2(s, err);\n}\n\nvec2 twoSqr(float a) {\n  float prod = a * a;\n  vec2 a_fp64 = split(a);\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  float err = ((a_fp64.x * a_fp64.x - prod) * ONE + 2.0 * a_fp64.x *\n    a_fp64.y * ONE * ONE) + a_fp64.y * a_fp64.y * ONE * ONE * ONE;\n#else\n  float err = ((a_fp64.x * a_fp64.x - prod) + 2.0 * a_fp64.x * a_fp64.y) + a_fp64.y * a_fp64.y;\n#endif\n  return vec2(prod, err);\n}\n\nvec2 twoProd(float a, float b) {\n  float prod = a * b;\n  vec2 a_fp64 = split(a);\n  vec2 b_fp64 = split(b);\n  float err = ((a_fp64.x * b_fp64.x - prod) + a_fp64.x * b_fp64.y +\n    a_fp64.y * b_fp64.x) + a_fp64.y * b_fp64.y;\n  return vec2(prod, err);\n}\n\nvec2 sum_fp64(vec2 a, vec2 b) {\n  vec2 s, t;\n  s = twoSum(a.x, b.x);\n  t = twoSum(a.y, b.y);\n  s.y += t.x;\n  s = quickTwoSum(s.x, s.y);\n  s.y += t.y;\n  s = quickTwoSum(s.x, s.y);\n  return s;\n}\n\nvec2 sub_fp64(vec2 a, vec2 b) {\n  vec2 s, t;\n  s = twoSub(a.x, b.x);\n  t = twoSub(a.y, b.y);\n  s.y += t.x;\n  s = quickTwoSum(s.x, s.y);\n  s.y += t.y;\n  s = quickTwoSum(s.x, s.y);\n  return s;\n}\n\nvec2 mul_fp64(vec2 a, vec2 b) {\n  vec2 prod = twoProd(a.x, b.x);\n  // y component is for the error\n  prod.y += a.x * b.y;\n#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)\n  prod = split2(prod);\n#endif\n  prod = quickTwoSum(prod.x, prod.y);\n  prod.y += a.y * b.x;\n#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)\n  prod = split2(prod);\n#endif\n  prod = quickTwoSum(prod.x, prod.y);\n  return prod;\n}\n\nvec2 div_fp64(vec2 a, vec2 b) {\n  float xn = 1.0 / b.x;\n#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)\n  vec2 yn = mul_fp64(a, vec2(xn, 0));\n#else\n  vec2 yn = a * xn;\n#endif\n  float diff = (sub_fp64(a, mul_fp64(b, yn))).x;\n  vec2 prod = twoProd(xn, diff);\n  return sum_fp64(yn, prod);\n}\n\nvec2 sqrt_fp64(vec2 a) {\n  if (a.x == 0.0 && a.y == 0.0) return vec2(0.0, 0.0);\n  if (a.x < 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);\n\n  float x = 1.0 / sqrt(a.x);\n  float yn = a.x * x;\n#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)\n  vec2 yn_sqr = twoSqr(yn) * ONE;\n#else\n  vec2 yn_sqr = twoSqr(yn);\n#endif\n  float diff = sub_fp64(a, yn_sqr).x;\n  vec2 prod = twoProd(x * 0.5, diff);\n#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)\n  return sum_fp64(split(yn), prod);\n#else\n  return sum_fp64(vec2(yn, 0.0), prod);\n#endif\n}\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const fp64functionShader = /* glsl */ `\\\nconst vec2 E_FP64 = vec2(2.7182817459106445e+00, 8.254840366817007e-08);\nconst vec2 LOG2_FP64 = vec2(0.6931471824645996e+00, -1.9046542121259336e-09);\nconst vec2 PI_FP64 = vec2(3.1415927410125732, -8.742278012618954e-8);\nconst vec2 TWO_PI_FP64 = vec2(6.2831854820251465, -1.7484556025237907e-7);\nconst vec2 PI_2_FP64 = vec2(1.5707963705062866, -4.371139006309477e-8);\nconst vec2 PI_4_FP64 = vec2(0.7853981852531433, -2.1855695031547384e-8);\nconst vec2 PI_16_FP64 = vec2(0.19634954631328583, -5.463923757886846e-9);\nconst vec2 PI_16_2_FP64 = vec2(0.39269909262657166, -1.0927847515773692e-8);\nconst vec2 PI_16_3_FP64 = vec2(0.5890486240386963, -1.4906100798128818e-9);\nconst vec2 PI_180_FP64 = vec2(0.01745329238474369, 1.3519960498364902e-10);\n\nconst vec2 SIN_TABLE_0_FP64 = vec2(0.19509032368659973, -1.6704714833615242e-9);\nconst vec2 SIN_TABLE_1_FP64 = vec2(0.3826834261417389, 6.22335089017767e-9);\nconst vec2 SIN_TABLE_2_FP64 = vec2(0.5555702447891235, -1.1769521357507529e-8);\nconst vec2 SIN_TABLE_3_FP64 = vec2(0.7071067690849304, 1.2101617041793133e-8);\n\nconst vec2 COS_TABLE_0_FP64 = vec2(0.9807852506637573, 2.9739473106360492e-8);\nconst vec2 COS_TABLE_1_FP64 = vec2(0.9238795042037964, 2.8307490351764386e-8);\nconst vec2 COS_TABLE_2_FP64 = vec2(0.8314695954322815, 1.6870263741530778e-8);\nconst vec2 COS_TABLE_3_FP64 = vec2(0.7071067690849304, 1.2101617152815436e-8);\n\nconst vec2 INVERSE_FACTORIAL_3_FP64 = vec2(1.666666716337204e-01, -4.967053879312289e-09); // 1/3!\nconst vec2 INVERSE_FACTORIAL_4_FP64 = vec2(4.16666679084301e-02, -1.2417634698280722e-09); // 1/4!\nconst vec2 INVERSE_FACTORIAL_5_FP64 = vec2(8.333333767950535e-03, -4.34617203337595e-10); // 1/5!\nconst vec2 INVERSE_FACTORIAL_6_FP64 = vec2(1.3888889225199819e-03, -3.3631094437103215e-11); // 1/6!\nconst vec2 INVERSE_FACTORIAL_7_FP64 = vec2(1.9841270113829523e-04,  -2.725596874933456e-12); // 1/7!\nconst vec2 INVERSE_FACTORIAL_8_FP64 = vec2(2.4801587642286904e-05, -3.406996025904184e-13); // 1/8!\nconst vec2 INVERSE_FACTORIAL_9_FP64 = vec2(2.75573188446287533e-06, 3.7935713937038186e-14); // 1/9!\nconst vec2 INVERSE_FACTORIAL_10_FP64 = vec2(2.755731998149713e-07, -7.575112367869873e-15); // 1/10!\n\nfloat nint(float d) {\n    if (d == floor(d)) return d;\n    return floor(d + 0.5);\n}\n\nvec2 nint_fp64(vec2 a) {\n    float hi = nint(a.x);\n    float lo;\n    vec2 tmp;\n    if (hi == a.x) {\n        lo = nint(a.y);\n        tmp = quickTwoSum(hi, lo);\n    } else {\n        lo = 0.0;\n        if (abs(hi - a.x) == 0.5 && a.y < 0.0) {\n            hi -= 1.0;\n        }\n        tmp = vec2(hi, lo);\n    }\n    return tmp;\n}\n\n/* k_power controls how much range reduction we would like to have\nRange reduction uses the following method:\nassume a = k_power * r + m * log(2), k and m being integers.\nSet k_power = 4 (we can choose other k to trade accuracy with performance.\nwe only need to calculate exp(r) and using exp(a) = 2^m * exp(r)^k_power;\n*/\n\nvec2 exp_fp64(vec2 a) {\n  // We need to make sure these two numbers match\n  // as bit-wise shift is not available in GLSL 1.0\n  const int k_power = 4;\n  const float k = 16.0;\n\n  const float inv_k = 1.0 / k;\n\n  if (a.x <= -88.0) return vec2(0.0, 0.0);\n  if (a.x >= 88.0) return vec2(1.0 / 0.0, 1.0 / 0.0);\n  if (a.x == 0.0 && a.y == 0.0) return vec2(1.0, 0.0);\n  if (a.x == 1.0 && a.y == 0.0) return E_FP64;\n\n  float m = floor(a.x / LOG2_FP64.x + 0.5);\n  vec2 r = sub_fp64(a, mul_fp64(LOG2_FP64, vec2(m, 0.0))) * inv_k;\n  vec2 s, t, p;\n\n  p = mul_fp64(r, r);\n  s = sum_fp64(r, p * 0.5);\n  p = mul_fp64(p, r);\n  t = mul_fp64(p, INVERSE_FACTORIAL_3_FP64);\n\n  s = sum_fp64(s, t);\n  p = mul_fp64(p, r);\n  t = mul_fp64(p, INVERSE_FACTORIAL_4_FP64);\n\n  s = sum_fp64(s, t);\n  p = mul_fp64(p, r);\n  t = mul_fp64(p, INVERSE_FACTORIAL_5_FP64);\n\n  // s = sum_fp64(s, t);\n  // p = mul_fp64(p, r);\n  // t = mul_fp64(p, INVERSE_FACTORIAL_6_FP64);\n\n  // s = sum_fp64(s, t);\n  // p = mul_fp64(p, r);\n  // t = mul_fp64(p, INVERSE_FACTORIAL_7_FP64);\n\n  s = sum_fp64(s, t);\n\n\n  // At this point, s = exp(r) - 1; but after following 4 recursions, we will get exp(r) ^ 512 - 1.\n  for (int i = 0; i < k_power; i++) {\n    s = sum_fp64(s * 2.0, mul_fp64(s, s));\n  }\n\n#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)\n  s = sum_fp64(s, vec2(ONE, 0.0));\n#else\n  s = sum_fp64(s, vec2(1.0, 0.0));\n#endif\n\n  return s * pow(2.0, m);\n//   return r;\n}\n\nvec2 log_fp64(vec2 a)\n{\n  if (a.x == 1.0 && a.y == 0.0) return vec2(0.0, 0.0);\n  if (a.x <= 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);\n  vec2 x = vec2(log(a.x), 0.0);\n  vec2 s;\n#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)\n  s = vec2(ONE, 0.0);\n#else\n  s = vec2(1.0, 0.0);\n#endif\n\n  x = sub_fp64(sum_fp64(x, mul_fp64(a, exp_fp64(-x))), s);\n  return x;\n}\n\nvec2 sin_taylor_fp64(vec2 a) {\n  vec2 r, s, t, x;\n\n  if (a.x == 0.0 && a.y == 0.0) {\n    return vec2(0.0, 0.0);\n  }\n\n  x = -mul_fp64(a, a);\n  s = a;\n  r = a;\n\n  r = mul_fp64(r, x);\n  t = mul_fp64(r, INVERSE_FACTORIAL_3_FP64);\n  s = sum_fp64(s, t);\n\n  r = mul_fp64(r, x);\n  t = mul_fp64(r, INVERSE_FACTORIAL_5_FP64);\n  s = sum_fp64(s, t);\n\n  /* keep the following commented code in case we need them\n  for extra accuracy from the Taylor expansion*/\n\n  // r = mul_fp64(r, x);\n  // t = mul_fp64(r, INVERSE_FACTORIAL_7_FP64);\n  // s = sum_fp64(s, t);\n\n  // r = mul_fp64(r, x);\n  // t = mul_fp64(r, INVERSE_FACTORIAL_9_FP64);\n  // s = sum_fp64(s, t);\n\n  return s;\n}\n\nvec2 cos_taylor_fp64(vec2 a) {\n  vec2 r, s, t, x;\n\n  if (a.x == 0.0 && a.y == 0.0) {\n    return vec2(1.0, 0.0);\n  }\n\n  x = -mul_fp64(a, a);\n  r = x;\n  s = sum_fp64(vec2(1.0, 0.0), r * 0.5);\n\n  r = mul_fp64(r, x);\n  t = mul_fp64(r, INVERSE_FACTORIAL_4_FP64);\n  s = sum_fp64(s, t);\n\n  r = mul_fp64(r, x);\n  t = mul_fp64(r, INVERSE_FACTORIAL_6_FP64);\n  s = sum_fp64(s, t);\n\n  /* keep the following commented code in case we need them\n  for extra accuracy from the Taylor expansion*/\n\n  // r = mul_fp64(r, x);\n  // t = mul_fp64(r, INVERSE_FACTORIAL_8_FP64);\n  // s = sum_fp64(s, t);\n\n  // r = mul_fp64(r, x);\n  // t = mul_fp64(r, INVERSE_FACTORIAL_10_FP64);\n  // s = sum_fp64(s, t);\n\n  return s;\n}\n\nvoid sincos_taylor_fp64(vec2 a, out vec2 sin_t, out vec2 cos_t) {\n  if (a.x == 0.0 && a.y == 0.0) {\n    sin_t = vec2(0.0, 0.0);\n    cos_t = vec2(1.0, 0.0);\n  }\n\n  sin_t = sin_taylor_fp64(a);\n  cos_t = sqrt_fp64(sub_fp64(vec2(1.0, 0.0), mul_fp64(sin_t, sin_t)));\n}\n\nvec2 sin_fp64(vec2 a) {\n    if (a.x == 0.0 && a.y == 0.0) {\n        return vec2(0.0, 0.0);\n    }\n\n    // 2pi range reduction\n    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));\n    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));\n\n    vec2 t;\n    float q = floor(r.x / PI_2_FP64.x + 0.5);\n    int j = int(q);\n\n    if (j < -2 || j > 2) {\n        return vec2(0.0 / 0.0, 0.0 / 0.0);\n    }\n\n    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));\n\n    q = floor(t.x / PI_16_FP64.x + 0.5);\n    int k = int(q);\n\n    if (k == 0) {\n        if (j == 0) {\n            return sin_taylor_fp64(t);\n        } else if (j == 1) {\n            return cos_taylor_fp64(t);\n        } else if (j == -1) {\n            return -cos_taylor_fp64(t);\n        } else {\n            return -sin_taylor_fp64(t);\n        }\n    }\n\n    int abs_k = int(abs(float(k)));\n\n    if (abs_k > 4) {\n        return vec2(0.0 / 0.0, 0.0 / 0.0);\n    } else {\n        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));\n    }\n\n    vec2 u = vec2(0.0, 0.0);\n    vec2 v = vec2(0.0, 0.0);\n\n#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)\n    if (abs(float(abs_k) - 1.0) < 0.5) {\n        u = COS_TABLE_0_FP64;\n        v = SIN_TABLE_0_FP64;\n    } else if (abs(float(abs_k) - 2.0) < 0.5) {\n        u = COS_TABLE_1_FP64;\n        v = SIN_TABLE_1_FP64;\n    } else if (abs(float(abs_k) - 3.0) < 0.5) {\n        u = COS_TABLE_2_FP64;\n        v = SIN_TABLE_2_FP64;\n    } else if (abs(float(abs_k) - 4.0) < 0.5) {\n        u = COS_TABLE_3_FP64;\n        v = SIN_TABLE_3_FP64;\n    }\n#else\n    if (abs_k == 1) {\n        u = COS_TABLE_0_FP64;\n        v = SIN_TABLE_0_FP64;\n    } else if (abs_k == 2) {\n        u = COS_TABLE_1_FP64;\n        v = SIN_TABLE_1_FP64;\n    } else if (abs_k == 3) {\n        u = COS_TABLE_2_FP64;\n        v = SIN_TABLE_2_FP64;\n    } else if (abs_k == 4) {\n        u = COS_TABLE_3_FP64;\n        v = SIN_TABLE_3_FP64;\n    }\n#endif\n\n    vec2 sin_t, cos_t;\n    sincos_taylor_fp64(t, sin_t, cos_t);\n\n\n\n    vec2 result = vec2(0.0, 0.0);\n    if (j == 0) {\n        if (k > 0) {\n            result = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));\n        } else {\n            result = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));\n        }\n    } else if (j == 1) {\n        if (k > 0) {\n            result = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));\n        } else {\n            result = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));\n        }\n    } else if (j == -1) {\n        if (k > 0) {\n            result = sub_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));\n        } else {\n            result = -sum_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));\n        }\n    } else {\n        if (k > 0) {\n            result = -sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));\n        } else {\n            result = sub_fp64(mul_fp64(v, cos_t), mul_fp64(u, sin_t));\n        }\n    }\n\n    return result;\n}\n\nvec2 cos_fp64(vec2 a) {\n    if (a.x == 0.0 && a.y == 0.0) {\n        return vec2(1.0, 0.0);\n    }\n\n    // 2pi range reduction\n    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));\n    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));\n\n    vec2 t;\n    float q = floor(r.x / PI_2_FP64.x + 0.5);\n    int j = int(q);\n\n    if (j < -2 || j > 2) {\n        return vec2(0.0 / 0.0, 0.0 / 0.0);\n    }\n\n    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));\n\n    q = floor(t.x / PI_16_FP64.x + 0.5);\n    int k = int(q);\n\n    if (k == 0) {\n        if (j == 0) {\n            return cos_taylor_fp64(t);\n        } else if (j == 1) {\n            return -sin_taylor_fp64(t);\n        } else if (j == -1) {\n            return sin_taylor_fp64(t);\n        } else {\n            return -cos_taylor_fp64(t);\n        }\n    }\n\n    int abs_k = int(abs(float(k)));\n\n    if (abs_k > 4) {\n        return vec2(0.0 / 0.0, 0.0 / 0.0);\n    } else {\n        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));\n    }\n\n    vec2 u = vec2(0.0, 0.0);\n    vec2 v = vec2(0.0, 0.0);\n\n#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)\n    if (abs(float(abs_k) - 1.0) < 0.5) {\n        u = COS_TABLE_0_FP64;\n        v = SIN_TABLE_0_FP64;\n    } else if (abs(float(abs_k) - 2.0) < 0.5) {\n        u = COS_TABLE_1_FP64;\n        v = SIN_TABLE_1_FP64;\n    } else if (abs(float(abs_k) - 3.0) < 0.5) {\n        u = COS_TABLE_2_FP64;\n        v = SIN_TABLE_2_FP64;\n    } else if (abs(float(abs_k) - 4.0) < 0.5) {\n        u = COS_TABLE_3_FP64;\n        v = SIN_TABLE_3_FP64;\n    }\n#else\n    if (abs_k == 1) {\n        u = COS_TABLE_0_FP64;\n        v = SIN_TABLE_0_FP64;\n    } else if (abs_k == 2) {\n        u = COS_TABLE_1_FP64;\n        v = SIN_TABLE_1_FP64;\n    } else if (abs_k == 3) {\n        u = COS_TABLE_2_FP64;\n        v = SIN_TABLE_2_FP64;\n    } else if (abs_k == 4) {\n        u = COS_TABLE_3_FP64;\n        v = SIN_TABLE_3_FP64;\n    }\n#endif\n\n    vec2 sin_t, cos_t;\n    sincos_taylor_fp64(t, sin_t, cos_t);\n\n    vec2 result = vec2(0.0, 0.0);\n    if (j == 0) {\n        if (k > 0) {\n            result = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));\n        } else {\n            result = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));\n        }\n    } else if (j == 1) {\n        if (k > 0) {\n            result = -sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));\n        } else {\n            result = sub_fp64(mul_fp64(v, cos_t), mul_fp64(u, sin_t));\n        }\n    } else if (j == -1) {\n        if (k > 0) {\n            result = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));\n        } else {\n            result = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));\n        }\n    } else {\n        if (k > 0) {\n            result = sub_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));\n        } else {\n            result = -sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));\n        }\n    }\n\n    return result;\n}\n\nvec2 tan_fp64(vec2 a) {\n    vec2 sin_a;\n    vec2 cos_a;\n\n    if (a.x == 0.0 && a.y == 0.0) {\n        return vec2(0.0, 0.0);\n    }\n\n    // 2pi range reduction\n    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));\n    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));\n\n    vec2 t;\n    float q = floor(r.x / PI_2_FP64.x + 0.5);\n    int j = int(q);\n\n\n    if (j < -2 || j > 2) {\n        return vec2(0.0 / 0.0, 0.0 / 0.0);\n    }\n\n    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));\n\n    q = floor(t.x / PI_16_FP64.x + 0.5);\n    int k = int(q);\n    int abs_k = int(abs(float(k)));\n\n    // We just can't get PI/16 * 3.0 very accurately.\n    // so let's just store it\n    if (abs_k > 4) {\n        return vec2(0.0 / 0.0, 0.0 / 0.0);\n    } else {\n        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));\n    }\n\n\n    vec2 u = vec2(0.0, 0.0);\n    vec2 v = vec2(0.0, 0.0);\n\n    vec2 sin_t, cos_t;\n    vec2 s, c;\n    sincos_taylor_fp64(t, sin_t, cos_t);\n\n    if (k == 0) {\n        s = sin_t;\n        c = cos_t;\n    } else {\n#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)\n        if (abs(float(abs_k) - 1.0) < 0.5) {\n            u = COS_TABLE_0_FP64;\n            v = SIN_TABLE_0_FP64;\n        } else if (abs(float(abs_k) - 2.0) < 0.5) {\n            u = COS_TABLE_1_FP64;\n            v = SIN_TABLE_1_FP64;\n        } else if (abs(float(abs_k) - 3.0) < 0.5) {\n            u = COS_TABLE_2_FP64;\n            v = SIN_TABLE_2_FP64;\n        } else if (abs(float(abs_k) - 4.0) < 0.5) {\n            u = COS_TABLE_3_FP64;\n            v = SIN_TABLE_3_FP64;\n        }\n#else\n        if (abs_k == 1) {\n            u = COS_TABLE_0_FP64;\n            v = SIN_TABLE_0_FP64;\n        } else if (abs_k == 2) {\n            u = COS_TABLE_1_FP64;\n            v = SIN_TABLE_1_FP64;\n        } else if (abs_k == 3) {\n            u = COS_TABLE_2_FP64;\n            v = SIN_TABLE_2_FP64;\n        } else if (abs_k == 4) {\n            u = COS_TABLE_3_FP64;\n            v = SIN_TABLE_3_FP64;\n        }\n#endif\n        if (k > 0) {\n            s = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));\n            c = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));\n        } else {\n            s = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));\n            c = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));\n        }\n    }\n\n    if (j == 0) {\n        sin_a = s;\n        cos_a = c;\n    } else if (j == 1) {\n        sin_a = c;\n        cos_a = -s;\n    } else if (j == -1) {\n        sin_a = -c;\n        cos_a = s;\n    } else {\n        sin_a = -s;\n        cos_a = -c;\n    }\n    return div_fp64(sin_a, cos_a);\n}\n\nvec2 radians_fp64(vec2 degree) {\n  return mul_fp64(degree, PI_180_FP64);\n}\n\nvec2 mix_fp64(vec2 a, vec2 b, float x) {\n  vec2 range = sub_fp64(b, a);\n  return sum_fp64(a, mul_fp64(range, vec2(x, 0.0)));\n}\n\n// Vector functions\n// vec2 functions\nvoid vec2_sum_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {\n    out_val[0] = sum_fp64(a[0], b[0]);\n    out_val[1] = sum_fp64(a[1], b[1]);\n}\n\nvoid vec2_sub_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {\n    out_val[0] = sub_fp64(a[0], b[0]);\n    out_val[1] = sub_fp64(a[1], b[1]);\n}\n\nvoid vec2_mul_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {\n    out_val[0] = mul_fp64(a[0], b[0]);\n    out_val[1] = mul_fp64(a[1], b[1]);\n}\n\nvoid vec2_div_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {\n    out_val[0] = div_fp64(a[0], b[0]);\n    out_val[1] = div_fp64(a[1], b[1]);\n}\n\nvoid vec2_mix_fp64(vec2 x[2], vec2 y[2], float a, out vec2 out_val[2]) {\n  vec2 range[2];\n  vec2_sub_fp64(y, x, range);\n  vec2 portion[2];\n  portion[0] = range[0] * a;\n  portion[1] = range[1] * a;\n  vec2_sum_fp64(x, portion, out_val);\n}\n\nvec2 vec2_length_fp64(vec2 x[2]) {\n  return sqrt_fp64(sum_fp64(mul_fp64(x[0], x[0]), mul_fp64(x[1], x[1])));\n}\n\nvoid vec2_normalize_fp64(vec2 x[2], out vec2 out_val[2]) {\n  vec2 length = vec2_length_fp64(x);\n  vec2 length_vec2[2];\n  length_vec2[0] = length;\n  length_vec2[1] = length;\n\n  vec2_div_fp64(x, length_vec2, out_val);\n}\n\nvec2 vec2_distance_fp64(vec2 x[2], vec2 y[2]) {\n  vec2 diff[2];\n  vec2_sub_fp64(x, y, diff);\n  return vec2_length_fp64(diff);\n}\n\nvec2 vec2_dot_fp64(vec2 a[2], vec2 b[2]) {\n  vec2 v[2];\n\n  v[0] = mul_fp64(a[0], b[0]);\n  v[1] = mul_fp64(a[1], b[1]);\n\n  return sum_fp64(v[0], v[1]);\n}\n\n// vec3 functions\nvoid vec3_sub_fp64(vec2 a[3], vec2 b[3], out vec2 out_val[3]) {\n  for (int i = 0; i < 3; i++) {\n    out_val[i] = sum_fp64(a[i], b[i]);\n  }\n}\n\nvoid vec3_sum_fp64(vec2 a[3], vec2 b[3], out vec2 out_val[3]) {\n  for (int i = 0; i < 3; i++) {\n    out_val[i] = sum_fp64(a[i], b[i]);\n  }\n}\n\nvec2 vec3_length_fp64(vec2 x[3]) {\n  return sqrt_fp64(sum_fp64(sum_fp64(mul_fp64(x[0], x[0]), mul_fp64(x[1], x[1])),\n    mul_fp64(x[2], x[2])));\n}\n\nvec2 vec3_distance_fp64(vec2 x[3], vec2 y[3]) {\n  vec2 diff[3];\n  vec3_sub_fp64(x, y, diff);\n  return vec3_length_fp64(diff);\n}\n\n// vec4 functions\nvoid vec4_fp64(vec4 a, out vec2 out_val[4]) {\n  out_val[0].x = a[0];\n  out_val[0].y = 0.0;\n\n  out_val[1].x = a[1];\n  out_val[1].y = 0.0;\n\n  out_val[2].x = a[2];\n  out_val[2].y = 0.0;\n\n  out_val[3].x = a[3];\n  out_val[3].y = 0.0;\n}\n\nvoid vec4_scalar_mul_fp64(vec2 a[4], vec2 b, out vec2 out_val[4]) {\n  out_val[0] = mul_fp64(a[0], b);\n  out_val[1] = mul_fp64(a[1], b);\n  out_val[2] = mul_fp64(a[2], b);\n  out_val[3] = mul_fp64(a[3], b);\n}\n\nvoid vec4_sum_fp64(vec2 a[4], vec2 b[4], out vec2 out_val[4]) {\n  for (int i = 0; i < 4; i++) {\n    out_val[i] = sum_fp64(a[i], b[i]);\n  }\n}\n\nvoid vec4_dot_fp64(vec2 a[4], vec2 b[4], out vec2 out_val) {\n  vec2 v[4];\n\n  v[0] = mul_fp64(a[0], b[0]);\n  v[1] = mul_fp64(a[1], b[1]);\n  v[2] = mul_fp64(a[2], b[2]);\n  v[3] = mul_fp64(a[3], b[3]);\n\n  out_val = sum_fp64(sum_fp64(v[0], v[1]), sum_fp64(v[2], v[3]));\n}\n\nvoid mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {\n  vec2 tmp[4];\n\n  for (int i = 0; i < 4; i++)\n  {\n    for (int j = 0; j < 4; j++)\n    {\n      tmp[j] = b[j + i * 4];\n    }\n    vec4_dot_fp64(a, tmp, out_val[i]);\n  }\n}\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { fp64ify, fp64LowPart, fp64ifyMatrix4 } from \"../../../modules/math/fp64/fp64-utils.js\";\nimport { fp64arithmeticShader } from \"./fp64-arithmetic-glsl.js\";\nimport { fp64functionShader } from \"./fp64-functions-glsl.js\";\nconst CONST_UNIFORMS = {\n    // Used in LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n    ONE: 1.0\n};\nexport { fp64ify, fp64LowPart, fp64ifyMatrix4 };\nfunction getUniforms() {\n    return CONST_UNIFORMS;\n}\n/**\n * 64bit arithmetic: add, sub, mul, div (small subset of fp64 module)\n */\nexport const fp64arithmetic = {\n    name: 'fp64-arithmetic',\n    vs: fp64arithmeticShader,\n    getUniforms,\n    fp64ify,\n    fp64LowPart,\n    fp64ifyMatrix4\n};\n/**\n * Full 64 bit math library\n */\nexport const fp64 = {\n    name: 'fp64',\n    vs: fp64functionShader,\n    dependencies: [fp64arithmetic],\n    // Additional Functions\n    fp64ify,\n    fp64LowPart,\n    fp64ifyMatrix4\n};\n", "// import {ShaderModule} from '../../types';\n// TODO - reuse normal from geometry module\nconst vs = /* glsl */ `\\\nvarying vec4 geometry_vPosition;\nvarying vec3 geometry_vNormal;\n\nvoid geometry_setNormal(vec3 normal) {\n  geometry_vNormal = normal;\n}\n\nvoid geometry_setPosition(vec4 position) {\n  geometry_vPosition = position;\n}\n\nvoid geometry_setPosition(vec3 position) {\n  geometry_vPosition = vec4(position, 1.);\n}\n`;\nconst fs = /* glsl */ `\\\nvarying vec4 geometry_vPosition;\nvarying vec3 geometry_vNormal;\n\nvec4 geometry_getPosition() {\n  return geometry_vPosition;\n}\n\nvec3 geometry_getNormal() {\n  return geometry_vNormal;\n}\n`;\n/**\n * Geometry varyings\n */\nexport const geometry = {\n    name: 'geometry',\n    vs,\n    fs\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { Matrix4 } from '@math.gl/core';\nconst IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];\nconst DEFAULT_MODULE_OPTIONS = {\n    modelMatrix: IDENTITY_MATRIX,\n    viewMatrix: IDENTITY_MATRIX,\n    projectionMatrix: IDENTITY_MATRIX,\n    cameraPositionWorld: [0, 0, 0]\n};\nfunction getUniforms(opts = DEFAULT_MODULE_OPTIONS, prevUniforms = {}) {\n    // const viewProjectionInverse = viewProjection.invert();\n    // viewInverseMatrix: view.invert(),\n    // viewProjectionInverseMatrix: viewProjectionInverse\n    const uniforms = {};\n    if (opts.modelMatrix !== undefined) {\n        uniforms.modelMatrix = opts.modelMatrix;\n    }\n    if (opts.viewMatrix !== undefined) {\n        uniforms.viewMatrix = opts.viewMatrix;\n    }\n    if (opts.projectionMatrix !== undefined) {\n        uniforms.projectionMatrix = opts.projectionMatrix;\n    }\n    if (opts.cameraPositionWorld !== undefined) {\n        uniforms.cameraPositionWorld = opts.cameraPositionWorld;\n    }\n    // COMPOSITE UNIFORMS\n    if (opts.projectionMatrix !== undefined && opts.viewMatrix !== undefined) {\n        uniforms.viewProjectionMatrix = new Matrix4(opts.projectionMatrix).multiplyRight(opts.viewMatrix);\n    }\n    return uniforms;\n}\nconst common = /* glsl */ `\\\nvarying vec4 project_vPositionWorld;\nvarying vec3 project_vNormalWorld;\n\nvec4 project_getPosition_World() {\n  return project_vPositionWorld;\n}\n\nvec3 project_getNormal_World() {\n  return project_vNormalWorld;\n}\n`;\nconst vs = `\\\n${common}\n\n// Unprefixed uniforms\nuniform mat4 modelMatrix;\nuniform mat4 viewMatrix;\nuniform mat4 projectionMatrix;\nuniform mat4 viewProjectionMatrix;\nuniform vec3 cameraPositionWorld;\n\nstruct World {\n  vec3 position;\n  vec3 normal;\n};\n\nWorld world;\n\nvoid project_setPosition(vec4 position) {\n  project_vPositionWorld = position;\n}\n\nvoid project_setNormal(vec3 normal) {\n  project_vNormalWorld = normal;\n}\n\nvoid project_setPositionAndNormal_World(vec3 position, vec3 normal) {\n  world.position = position;\n  world.normal = normal;\n}\n\nvoid project_setPositionAndNormal_Model(vec3 position, vec3 normal) {\n  world.position = (modelMatrix * vec4(position, 1.)).xyz;\n  world.normal = mat3(modelMatrix) * normal;\n}\n\nvec4 project_model_to_clipspace(vec4 position) {\n  return viewProjectionMatrix * modelMatrix * position;\n}\n\nvec4 project_model_to_clipspace(vec3 position) {\n  return viewProjectionMatrix * modelMatrix * vec4(position, 1.);\n}\n\nvec4 project_world_to_clipspace(vec3 position) {\n  return viewProjectionMatrix * vec4(position, 1.);\n}\n\nvec4 project_view_to_clipspace(vec3 position) {\n  return projectionMatrix * vec4(position, 1.);\n}\n\nvec4 project_to_clipspace(vec3 position) {\n  return viewProjectionMatrix * vec4(position, 1.);\n}\n`;\nconst fs = `\n${common}\\\n`;\n/**\n * Projects coordinates\n */\nexport const project = {\n    name: 'project',\n    getUniforms,\n    vs,\n    fs\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const lightingShader = /* glsl */ `\\\n#if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))\n\nstruct AmbientLight {\n vec3 color;\n};\n\nstruct PointLight {\n vec3 color;\n vec3 position;\n\n // Constant-Linear-Exponential\n vec3 attenuation;\n};\n\nstruct DirectionalLight {\n  vec3 color;\n  vec3 direction;\n};\n\nuniform AmbientLight lighting_uAmbientLight;\nuniform PointLight lighting_uPointLight[MAX_LIGHTS];\nuniform DirectionalLight lighting_uDirectionalLight[MAX_LIGHTS];\nuniform int lighting_uPointLightCount;\nuniform int lighting_uDirectionalLightCount;\n\nuniform bool lighting_uEnabled;\n\nfloat getPointLightAttenuation(PointLight pointLight, float distance) {\n  return pointLight.attenuation.x\n       + pointLight.attenuation.y * distance\n       + pointLight.attenuation.z * distance * distance;\n}\n\n#endif\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { lightingShader } from \"./lights-glsl.js\";\nconst INITIAL_MODULE_OPTIONS = {\n    lightSources: {}\n};\n// Take color 0-255 and intensity as input and output 0.0-1.0 range\nfunction convertColor(colorDef = {}) {\n    const { color = [0, 0, 0], intensity = 1.0 } = colorDef;\n    return color.map(component => (component * intensity) / 255.0);\n}\nfunction getLightSourceUniforms({ ambientLight, pointLights = [], directionalLights = [] }) {\n    const lightSourceUniforms = {};\n    if (ambientLight) {\n        lightSourceUniforms['lighting_uAmbientLight.color'] = convertColor(ambientLight);\n    }\n    else {\n        lightSourceUniforms['lighting_uAmbientLight.color'] = [0, 0, 0];\n    }\n    pointLights.forEach((pointLight, index) => {\n        lightSourceUniforms[`lighting_uPointLight[${index}].color`] = convertColor(pointLight);\n        lightSourceUniforms[`lighting_uPointLight[${index}].position`] = pointLight.position;\n        lightSourceUniforms[`lighting_uPointLight[${index}].attenuation`] = pointLight.attenuation || [\n            1, 0, 0\n        ];\n    });\n    lightSourceUniforms.lighting_uPointLightCount = pointLights.length;\n    directionalLights.forEach((directionalLight, index) => {\n        lightSourceUniforms[`lighting_uDirectionalLight[${index}].color`] =\n            convertColor(directionalLight);\n        lightSourceUniforms[`lighting_uDirectionalLight[${index}].direction`] =\n            directionalLight.direction;\n    });\n    lightSourceUniforms.lighting_uDirectionalLightCount = directionalLights.length;\n    return lightSourceUniforms;\n}\n// eslint-disable-next-line complexity\nfunction getUniforms(opts = INITIAL_MODULE_OPTIONS) {\n    // Specify lights separately\n    if ('lightSources' in opts) {\n        const { ambientLight, pointLights, directionalLights } = opts.lightSources || {};\n        const hasLights = ambientLight ||\n            (pointLights && pointLights.length > 0) ||\n            (directionalLights && directionalLights.length > 0);\n        if (!hasLights) {\n            return { lighting_uEnabled: false };\n        }\n        return Object.assign({}, getLightSourceUniforms({ ambientLight, pointLights, directionalLights }), {\n            lighting_uEnabled: true\n        });\n    }\n    // Support for array of lights. Type of light is detected by type field\n    if ('lights' in opts) {\n        const lightSources = { pointLights: [], directionalLights: [] };\n        // @ts-expect-error\n        for (const light of opts.lights || []) {\n            switch (light.type) {\n                case 'ambient':\n                    // Note: Only uses last ambient light\n                    // TODO - add ambient light sources on CPU?\n                    lightSources.ambientLight = light;\n                    break;\n                case 'directional':\n                    lightSources.directionalLights?.push(light);\n                    break;\n                case 'point':\n                    lightSources.pointLights?.push(light);\n                    break;\n                default:\n                // eslint-disable-next-line\n                // console.warn(light.type);\n            }\n        }\n        // Call the `opts.lightSources`` version\n        return getUniforms({ lightSources });\n    }\n    return {};\n}\n/**\n * An implementation of PBR (Physically-Based Rendering).\n * Physically Based Shading of a microfacet surface defined by a glTF material.\n */\nexport const lights = {\n    name: 'lights',\n    vs: lightingShader,\n    fs: lightingShader,\n    getUniforms,\n    defines: {\n        MAX_LIGHTS: 3\n    }\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { project } from \"../../project/project.js\";\nconst DEFAULT_MODULE_OPTIONS = {\n    lightDirection: new Float32Array([1, 1, 2])\n};\nfunction getUniforms(opts = DEFAULT_MODULE_OPTIONS) {\n    const uniforms = {};\n    if (opts.lightDirection) {\n        // @ts-expect-error TODO add types\n        uniforms.dirlight_uLightDirection = opts.lightDirection;\n    }\n    return uniforms;\n}\nconst fs = /* glsl */ `\\\nuniform vec3 dirlight_uLightDirection;\n\n/*\n * Returns color attenuated by angle from light source\n */\nvec4 dirlight_filterColor(vec4 color) {\n  vec3 normal = project_getNormal_World();\n  float d = abs(dot(normalize(normal), normalize(dirlight_uLightDirection)));\n  return vec4(color.rgb * d, color.a);\n}\n`;\n/**\n * Cheap lighting - single directional light, single dot product, one uniform\n */\nexport const dirlight = {\n    name: 'dirlight',\n    // vs // TODO - reuse normal from geometry module\n    fs,\n    getUniforms,\n    dependencies: [project]\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const lightingShader = /* glsl */ `\\\n\nuniform float lighting_uAmbient;\nuniform float lighting_uDiffuse;\nuniform float lighting_uShininess;\nuniform vec3  lighting_uSpecularColor;\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {\n    vec3 halfway_direction = normalize(light_direction + view_direction);\n    float lambertian = dot(light_direction, normal_worldspace);\n    float specular = 0.0;\n    if (lambertian > 0.0) {\n      float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);\n      specular = pow(specular_angle, lighting_uShininess);\n    }\n    lambertian = max(lambertian, 0.0);\n    return (lambertian * lighting_uDiffuse * surfaceColor + specular * lighting_uSpecularColor) * color;\n}\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = surfaceColor;\n\n  if (lighting_uEnabled) {\n    vec3 view_direction = normalize(cameraPosition - position_worldspace);\n    lightColor = lighting_uAmbient * surfaceColor * lighting_uAmbientLight.color;\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting_uPointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_uPointLight[i];\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting_uDirectionalLightCount) {\n        break;\n      }\n      DirectionalLight directionalLight = lighting_uDirectionalLight[i];\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n  }\n  return lightColor;\n}\n\nvec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = vec3(0, 0, 0);\n  vec3 surfaceColor = vec3(0, 0, 0);\n\n  if (lighting_uEnabled) {\n    vec3 view_direction = normalize(cameraPosition - position_worldspace);\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting_uPointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting_uPointLight[i];\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting_uDirectionalLightCount) {\n        break;\n      }\n      DirectionalLight directionalLight = lighting_uDirectionalLight[i];\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n  }\n  return lightColor;\n}\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { lights } from \"../lights/lights.js\";\nimport { lightingShader } from \"./phong-lighting-glsl.js\";\nconst INITIAL_MODULE_OPTIONS = {};\nfunction getMaterialUniforms(material) {\n    const { ambient = 0.35, diffuse = 0.6, shininess = 32, specularColor = [30, 30, 30] } = material;\n    return {\n        lighting_uAmbient: ambient,\n        lighting_uDiffuse: diffuse,\n        lighting_uShininess: shininess,\n        lighting_uSpecularColor: specularColor.map(x => x / 255)\n    };\n}\nfunction getUniforms(opts = INITIAL_MODULE_OPTIONS) {\n    if (!('material' in opts)) {\n        return {};\n    }\n    const { material } = opts;\n    if (!material) {\n        return { lighting_uEnabled: false };\n    }\n    return getMaterialUniforms(material);\n}\nexport const gouraudLighting = {\n    name: 'gouraud-lighting',\n    dependencies: [lights],\n    vs: lightingShader,\n    defines: {\n        LIGHTING_VERTEX: 1\n    },\n    getUniforms\n};\nexport const phongLighting = {\n    name: 'phong-lighting',\n    dependencies: [lights],\n    fs: lightingShader,\n    defines: {\n        LIGHTING_FRAGMENT: 1\n    },\n    getUniforms\n};\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport const vs = /* glsl */ `\\\nuniform mat4 u_MVPMatrix;\nuniform mat4 u_ModelMatrix;\nuniform mat4 u_NormalMatrix;\n\nout vec3 pbr_vPosition;\nout vec2 pbr_vUV;\n\n#ifdef HAS_NORMALS\n# ifdef HAS_TANGENTS\nout mat3 pbr_vTBN;\n# else\nout vec3 pbr_vNormal;\n# endif\n#endif\n\nvoid pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)\n{\n  vec4 pos = u_ModelMatrix * position;\n  pbr_vPosition = vec3(pos.xyz) / pos.w;\n\n#ifdef HAS_NORMALS\n#ifdef HAS_TANGENTS\n  vec3 normalW = normalize(vec3(u_NormalMatrix * vec4(normal.xyz, 0.0)));\n  vec3 tangentW = normalize(vec3(u_ModelMatrix * vec4(tangent.xyz, 0.0)));\n  vec3 bitangentW = cross(normalW, tangentW) * tangent.w;\n  pbr_vTBN = mat3(tangentW, bitangentW, normalW);\n#else // HAS_TANGENTS != 1\n  pbr_vNormal = normalize(vec3(u_ModelMatrix * vec4(normal.xyz, 0.0)));\n#endif\n#endif\n\n#ifdef HAS_UV\n  pbr_vUV = uv;\n#else\n  pbr_vUV = vec2(0.,0.);\n#endif\n}\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// Attribution:\n// MIT license, Copyright (c) 2016-2017 Mohamad Moneimne and Contributors\n// This fragment shader defines a reference implementation for Physically Based Shading of\n// a microfacet surface material defined by a glTF model.\n//\n// TODO - better do the checks outside of shader\nexport const fs = /* glsl */ `\\\nprecision highp float;\n\nuniform bool pbr_uUnlit;\n\n#ifdef USE_IBL\nuniform samplerCube u_DiffuseEnvSampler;\nuniform samplerCube u_SpecularEnvSampler;\nuniform sampler2D u_brdfLUT;\nuniform vec2 u_ScaleIBLAmbient;\n#endif\n\n#ifdef HAS_BASECOLORMAP\nuniform sampler2D u_BaseColorSampler;\n#endif\n#ifdef HAS_NORMALMAP\nuniform sampler2D u_NormalSampler;\nuniform float u_NormalScale;\n#endif\n#ifdef HAS_EMISSIVEMAP\nuniform sampler2D u_EmissiveSampler;\nuniform vec3 u_EmissiveFactor;\n#endif\n#ifdef HAS_METALROUGHNESSMAP\nuniform sampler2D u_MetallicRoughnessSampler;\n#endif\n#ifdef HAS_OCCLUSIONMAP\nuniform sampler2D u_OcclusionSampler;\nuniform float u_OcclusionStrength;\n#endif\n\n#ifdef ALPHA_CUTOFF\nuniform float u_AlphaCutoff;\n#endif\n\nuniform vec2 u_MetallicRoughnessValues;\nuniform vec4 u_BaseColorFactor;\n\nuniform vec3 u_Camera;\n\n// debugging flags used for shader output of intermediate PBR variables\n#ifdef PBR_DEBUG\nuniform vec4 u_ScaleDiffBaseMR;\nuniform vec4 u_ScaleFGDSpec;\n#endif\n\nin vec3 pbr_vPosition;\n\nin vec2 pbr_vUV;\n\n#ifdef HAS_NORMALS\n#ifdef HAS_TANGENTS\nin mat3 pbr_vTBN;\n#else\nin vec3 pbr_vNormal;\n#endif\n#endif\n\n// Encapsulate the various inputs used by the various functions in the shading equation\n// We store values in this struct to simplify the integration of alternative implementations\n// of the shading terms, outlined in the Readme.MD Appendix.\nstruct PBRInfo\n{\n  float NdotL;                  // cos angle between normal and light direction\n  float NdotV;                  // cos angle between normal and view direction\n  float NdotH;                  // cos angle between normal and half vector\n  float LdotH;                  // cos angle between light direction and half vector\n  float VdotH;                  // cos angle between view direction and half vector\n  float perceptualRoughness;    // roughness value, as authored by the model creator (input to shader)\n  float metalness;              // metallic value at the surface\n  vec3 reflectance0;            // full reflectance color (normal incidence angle)\n  vec3 reflectance90;           // reflectance color at grazing angle\n  float alphaRoughness;         // roughness mapped to a more linear change in the roughness (proposed by [2])\n  vec3 diffuseColor;            // color contribution from diffuse lighting\n  vec3 specularColor;           // color contribution from specular lighting\n  vec3 n;                       // normal at surface point\n  vec3 v;                       // vector from surface point to camera\n};\n\nconst float M_PI = 3.141592653589793;\nconst float c_MinRoughness = 0.04;\n\nvec4 SRGBtoLINEAR(vec4 srgbIn)\n{\n#ifdef MANUAL_SRGB\n#ifdef SRGB_FAST_APPROXIMATION\n  vec3 linOut = pow(srgbIn.xyz,vec3(2.2));\n#else //SRGB_FAST_APPROXIMATION\n  vec3 bLess = step(vec3(0.04045),srgbIn.xyz);\n  vec3 linOut = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );\n#endif //SRGB_FAST_APPROXIMATION\n  return vec4(linOut,srgbIn.w);;\n#else //MANUAL_SRGB\n  return srgbIn;\n#endif //MANUAL_SRGB\n}\n\n// Find the normal for this fragment, pulling either from a predefined normal map\n// or from the interpolated mesh normal and tangent attributes.\nvec3 getNormal()\n{\n  // Retrieve the tangent space matrix\n#ifndef HAS_TANGENTS\n  vec3 pos_dx = dFdx(pbr_vPosition);\n  vec3 pos_dy = dFdy(pbr_vPosition);\n  vec3 tex_dx = dFdx(vec3(pbr_vUV, 0.0));\n  vec3 tex_dy = dFdy(vec3(pbr_vUV, 0.0));\n  vec3 t = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);\n\n#ifdef HAS_NORMALS\n  vec3 ng = normalize(pbr_vNormal);\n#else\n  vec3 ng = cross(pos_dx, pos_dy);\n#endif\n\n  t = normalize(t - ng * dot(ng, t));\n  vec3 b = normalize(cross(ng, t));\n  mat3 tbn = mat3(t, b, ng);\n#else // HAS_TANGENTS\n  mat3 tbn = pbr_vTBN;\n#endif\n\n#ifdef HAS_NORMALMAP\n  vec3 n = texture(u_NormalSampler, pbr_vUV).rgb;\n  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(u_NormalScale, u_NormalScale, 1.0)));\n#else\n  // The tbn matrix is linearly interpolated, so we need to re-normalize\n  vec3 n = normalize(tbn[2].xyz);\n#endif\n\n  return n;\n}\n\n// Calculation of the lighting contribution from an optional Image Based Light source.\n// Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].\n// See our README.md on Environment Maps [3] for additional discussion.\n#ifdef USE_IBL\nvec3 getIBLContribution(PBRInfo pbrInputs, vec3 n, vec3 reflection)\n{\n  float mipCount = 9.0; // resolution of 512x512\n  float lod = (pbrInputs.perceptualRoughness * mipCount);\n  // retrieve a scale and bias to F0. See [1], Figure 3\n  vec3 brdf = SRGBtoLINEAR(texture(u_brdfLUT,\n    vec2(pbrInputs.NdotV, 1.0 - pbrInputs.perceptualRoughness))).rgb;\n  vec3 diffuseLight = SRGBtoLINEAR(textureCube(u_DiffuseEnvSampler, n)).rgb;\n\n#ifdef USE_TEX_LOD\n  vec3 specularLight = SRGBtoLINEAR(textureCubeLod(u_SpecularEnvSampler, reflection, lod)).rgb;\n#else\n  vec3 specularLight = SRGBtoLINEAR(textureCube(u_SpecularEnvSampler, reflection)).rgb;\n#endif\n\n  vec3 diffuse = diffuseLight * pbrInputs.diffuseColor;\n  vec3 specular = specularLight * (pbrInputs.specularColor * brdf.x + brdf.y);\n\n  // For presentation, this allows us to disable IBL terms\n  diffuse *= u_ScaleIBLAmbient.x;\n  specular *= u_ScaleIBLAmbient.y;\n\n  return diffuse + specular;\n}\n#endif\n\n// Basic Lambertian diffuse\n// Implementation from Lambert's Photometria https://archive.org/details/lambertsphotome00lambgoog\n// See also [1], Equation 1\nvec3 diffuse(PBRInfo pbrInputs)\n{\n  return pbrInputs.diffuseColor / M_PI;\n}\n\n// The following equation models the Fresnel reflectance term of the spec equation (aka F())\n// Implementation of fresnel from [4], Equation 15\nvec3 specularReflection(PBRInfo pbrInputs)\n{\n  return pbrInputs.reflectance0 +\n    (pbrInputs.reflectance90 - pbrInputs.reflectance0) *\n    pow(clamp(1.0 - pbrInputs.VdotH, 0.0, 1.0), 5.0);\n}\n\n// This calculates the specular geometric attenuation (aka G()),\n// where rougher material will reflect less light back to the viewer.\n// This implementation is based on [1] Equation 4, and we adopt their modifications to\n// alphaRoughness as input as originally proposed in [2].\nfloat geometricOcclusion(PBRInfo pbrInputs)\n{\n  float NdotL = pbrInputs.NdotL;\n  float NdotV = pbrInputs.NdotV;\n  float r = pbrInputs.alphaRoughness;\n\n  float attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));\n  float attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));\n  return attenuationL * attenuationV;\n}\n\n// The following equation(s) model the distribution of microfacet normals across\n// the area being drawn (aka D())\n// Implementation from \"Average Irregularity Representation of a Roughened Surface\n// for Ray Reflection\" by T. S. Trowbridge, and K. P. Reitz\n// Follows the distribution function recommended in the SIGGRAPH 2013 course notes\n// from EPIC Games [1], Equation 3.\nfloat microfacetDistribution(PBRInfo pbrInputs)\n{\n  float roughnessSq = pbrInputs.alphaRoughness * pbrInputs.alphaRoughness;\n  float f = (pbrInputs.NdotH * roughnessSq - pbrInputs.NdotH) * pbrInputs.NdotH + 1.0;\n  return roughnessSq / (M_PI * f * f);\n}\n\nvoid PBRInfo_setAmbientLight(inout PBRInfo pbrInputs) {\n  pbrInputs.NdotL = 1.0;\n  pbrInputs.NdotH = 0.0;\n  pbrInputs.LdotH = 0.0;\n  pbrInputs.VdotH = 1.0;\n}\n\nvoid PBRInfo_setDirectionalLight(inout PBRInfo pbrInputs, vec3 lightDirection) {\n  vec3 n = pbrInputs.n;\n  vec3 v = pbrInputs.v;\n  vec3 l = normalize(lightDirection);             // Vector from surface point to light\n  vec3 h = normalize(l+v);                        // Half vector between both l and v\n\n  pbrInputs.NdotL = clamp(dot(n, l), 0.001, 1.0);\n  pbrInputs.NdotH = clamp(dot(n, h), 0.0, 1.0);\n  pbrInputs.LdotH = clamp(dot(l, h), 0.0, 1.0);\n  pbrInputs.VdotH = clamp(dot(v, h), 0.0, 1.0);\n}\n\nvoid PBRInfo_setPointLight(inout PBRInfo pbrInputs, PointLight pointLight) {\n  vec3 light_direction = normalize(pointLight.position - pbr_vPosition);\n  PBRInfo_setDirectionalLight(pbrInputs, light_direction);\n}\n\nvec3 calculateFinalColor(PBRInfo pbrInputs, vec3 lightColor) {\n  // Calculate the shading terms for the microfacet specular shading model\n  vec3 F = specularReflection(pbrInputs);\n  float G = geometricOcclusion(pbrInputs);\n  float D = microfacetDistribution(pbrInputs);\n\n  // Calculation of analytical lighting contribution\n  vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInputs);\n  vec3 specContrib = F * G * D / (4.0 * pbrInputs.NdotL * pbrInputs.NdotV);\n  // Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)\n  return pbrInputs.NdotL * lightColor * (diffuseContrib + specContrib);\n}\n\nvec4 pbr_filterColor(vec4 colorUnused)\n{\n  // The albedo may be defined from a base texture or a flat color\n#ifdef HAS_BASECOLORMAP\n  vec4 baseColor = SRGBtoLINEAR(texture(u_BaseColorSampler, pbr_vUV)) * u_BaseColorFactor;\n#else\n  vec4 baseColor = u_BaseColorFactor;\n#endif\n\n#ifdef ALPHA_CUTOFF\n  if (baseColor.a < u_AlphaCutoff) {\n    discard;\n  }\n#endif\n\n  vec3 color = vec3(0, 0, 0);\n\n  if(pbr_uUnlit){\n    color.rgb = baseColor.rgb;\n  }\n  else{\n    // Metallic and Roughness material properties are packed together\n    // In glTF, these factors can be specified by fixed scalar values\n    // or from a metallic-roughness map\n    float perceptualRoughness = u_MetallicRoughnessValues.y;\n    float metallic = u_MetallicRoughnessValues.x;\n#ifdef HAS_METALROUGHNESSMAP\n    // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.\n    // This layout intentionally reserves the 'r' channel for (optional) occlusion map data\n    vec4 mrSample = texture(u_MetallicRoughnessSampler, pbr_vUV);\n    perceptualRoughness = mrSample.g * perceptualRoughness;\n    metallic = mrSample.b * metallic;\n#endif\n    perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);\n    metallic = clamp(metallic, 0.0, 1.0);\n    // Roughness is authored as perceptual roughness; as is convention,\n    // convert to material roughness by squaring the perceptual roughness [2].\n    float alphaRoughness = perceptualRoughness * perceptualRoughness;\n\n    vec3 f0 = vec3(0.04);\n    vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);\n    diffuseColor *= 1.0 - metallic;\n    vec3 specularColor = mix(f0, baseColor.rgb, metallic);\n\n    // Compute reflectance.\n    float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);\n\n    // For typical incident reflectance range (between 4% to 100%) set the grazing\n    // reflectance to 100% for typical fresnel effect.\n    // For very low reflectance range on highly diffuse objects (below 4%),\n    // incrementally reduce grazing reflecance to 0%.\n    float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);\n    vec3 specularEnvironmentR0 = specularColor.rgb;\n    vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;\n\n    vec3 n = getNormal();                          // normal at surface point\n    vec3 v = normalize(u_Camera - pbr_vPosition);  // Vector from surface point to camera\n\n    float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);\n    vec3 reflection = -normalize(reflect(v, n));\n\n    PBRInfo pbrInputs = PBRInfo(\n      0.0, // NdotL\n      NdotV,\n      0.0, // NdotH\n      0.0, // LdotH\n      0.0, // VdotH\n      perceptualRoughness,\n      metallic,\n      specularEnvironmentR0,\n      specularEnvironmentR90,\n      alphaRoughness,\n      diffuseColor,\n      specularColor,\n      n,\n      v\n    );\n\n#ifdef USE_LIGHTS\n    // Apply ambient light\n    PBRInfo_setAmbientLight(pbrInputs);\n    color += calculateFinalColor(pbrInputs, lighting_uAmbientLight.color);\n\n    // Apply directional light\n    for(int i = 0; i < lighting_uDirectionalLightCount; i++) {\n      if (i < lighting_uDirectionalLightCount) {\n        PBRInfo_setDirectionalLight(pbrInputs, lighting_uDirectionalLight[i].direction);\n        color += calculateFinalColor(pbrInputs, lighting_uDirectionalLight[i].color);\n      }\n    }\n\n    // Apply point light\n    for(int i = 0; i < lighting_uPointLightCount; i++) {\n      if (i < lighting_uPointLightCount) {\n        PBRInfo_setPointLight(pbrInputs, lighting_uPointLight[i]);\n        float attenuation = getPointLightAttenuation(lighting_uPointLight[i], distance(lighting_uPointLight[i].position, pbr_vPosition));\n        color += calculateFinalColor(pbrInputs, lighting_uPointLight[i].color / attenuation);\n      }\n    }\n#endif\n\n    // Calculate lighting contribution from image based lighting source (IBL)\n#ifdef USE_IBL\n    color += getIBLContribution(pbrInputs, n, reflection);\n#endif\n\n    // Apply optional PBR terms for additional (optional) shading\n#ifdef HAS_OCCLUSIONMAP\n    float ao = texture(u_OcclusionSampler, pbr_vUV).r;\n    color = mix(color, color * ao, u_OcclusionStrength);\n#endif\n\n#ifdef HAS_EMISSIVEMAP\n    vec3 emissive = SRGBtoLINEAR(texture(u_EmissiveSampler, pbr_vUV)).rgb * u_EmissiveFactor;\n    color += emissive;\n#endif\n\n    // This section uses mix to override final color for reference app visualization\n    // of various parameters in the lighting equation.\n#ifdef PBR_DEBUG\n    // TODO: Figure out how to debug multiple lights\n\n    // color = mix(color, F, u_ScaleFGDSpec.x);\n    // color = mix(color, vec3(G), u_ScaleFGDSpec.y);\n    // color = mix(color, vec3(D), u_ScaleFGDSpec.z);\n    // color = mix(color, specContrib, u_ScaleFGDSpec.w);\n\n    // color = mix(color, diffuseContrib, u_ScaleDiffBaseMR.x);\n    color = mix(color, baseColor.rgb, u_ScaleDiffBaseMR.y);\n    color = mix(color, vec3(metallic), u_ScaleDiffBaseMR.z);\n    color = mix(color, vec3(perceptualRoughness), u_ScaleDiffBaseMR.w);\n#endif\n\n  }\n\n  return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);\n}\n`;\n", "// luma.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { lights } from \"../lights/lights.js\";\nimport { vs } from \"./pbr-vertex-glsl.js\";\nimport { fs } from \"./pbr-fragment-glsl.js\";\n/**\n * An implementation of PBR (Physically-Based Rendering).\n * Physically Based Shading of a microfacet surface defined by a glTF material.\n */\nexport const pbr = {\n    name: 'pbr',\n    vs,\n    fs,\n    defines: {\n        LIGHTING_FRAGMENT: 1\n    },\n    dependencies: [lights],\n    getUniforms: (props) => props\n};\n"],
+  "mappings": "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AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;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A;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwkBJ,IAAM,OAAO;AAAA,EAChB,MAAM;AAAA,EACN,kBAAkB,CAAC;AAAA,EACnB,IAAAA;AAAA,EACA,QAAQ,CAAC,EAAE,SAAS,KAAK,CAAC;AAAA,EAC1B,aAAa,WAAS;AAC1B;;;ACxqBO,IAAM;AAAA;AAAA,EAAkC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAxC,IAAM;AAAA;AAAA,EAAgC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;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",
   "names": ["dirlight", "module", "log", "_a", "module", "vs", "fs", "log", "module", "getUniforms", "module", "getUniforms", "module", "module", "module", "import_core", "fs", "LIGHT_TYPE", "getUniforms", "lights", "getUniforms", "vs", "fs", "vs", "fs", "fs", "fs", "fs", "fs", "fs", "fs", "fs", "fs", "fs", "fs", "fs", "fs", "fs", "fs", "fs", "fs", "fs", "fs", "fs", "fs", "getUniforms", "vs", "fs", "import_core", "getUniforms", "vs", "fs", "convertColor", "getLightSourceUniforms", "getUniforms", "DEFAULT_MODULE_OPTIONS", "getUniforms", "fs", "dirlight", "lightingShader", "INITIAL_MODULE_OPTIONS", "getUniforms", "lightingShader", "vs", "fs", "vs", "fs"]
 }