npm - @luma.gl/shadertools - Versions diffs - 8.5.19 → 8.5.20 - Mend

@luma.gl/shadertools 8.5.19 → 8.5.20

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (111) hide show

package/dist/es5/bundle.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"~~sources~~":["~~../../src/~~bundle.js"],"names":["moduleExports","require","globalThis","luma","module","exports","Object","assign"],"~~mappings~~":"~~;;AAAA,IAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AAGAC,UAAU,CAACC,IAAX,GAAkBD,UAAU,CAACC,IAAX,IAAmB,EAArC;AAEAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,IAAzB,EAA+BH,aAA~~/~~B,CAAjB~~","sourcesContent":["const moduleExports = require('./index');\n\n// @ts-ignore\nglobalThis.luma = globalThis.luma \|\| {};\n// @ts-ignore\nmodule.exports = Object.assign(globalThis.luma, moduleExports);\n"],"~~file~~":"~~bundle.js~~"}
1	+ {"version":3,"file":"bundle.js","names":["moduleExports","require","globalThis","luma","module","exports","Object","assign"],"sources":["../../src/bundle.js"],"sourcesContent":["const moduleExports = require('./index');\n\n// @ts-ignore\nglobalThis.luma = globalThis.luma \|\| {};\n// @ts-ignore\nmodule.exports = Object.assign(globalThis.luma, moduleExports);\n"],"mappings":";;AAAA,IAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AAGAC,UAAU,CAACC,IAAX,GAAkBD,UAAU,CAACC,IAAX,IAAmB,EAArC;AAEAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,IAAzB,EAA+BH,aAA/B,CAAjB"}

package/dist/es5/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"~~sources~~":["~~../../src/~~index.js"],"names":[],"~~mappings~~":"~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA;;AAGA;;AACA;;AAGA;;AASA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA~~","sourcesContent":["// shadertools exports\n\n// DOCUMENTED APIS\nexport {assembleShaders} from './lib/assemble-shaders';\n\n// HELPERS\nexport {combineInjects} from './lib/inject-shader';\nexport {normalizeShaderModule} from './lib/shader-module';\n\n// UTILS\nexport {\n getQualifierDetails,\n getPassthroughFS,\n typeToChannelSuffix,\n typeToChannelCount,\n convertToVec4\n} from './utils/shader-utils';\n\n// SHADER MODULES\nexport * from './modules';\n"],"~~file~~":"~~index.js~~"}
1	+ {"version":3,"file":"index.js","names":[],"sources":["../../src/index.js"],"sourcesContent":["// shadertools exports\n\n// DOCUMENTED APIS\nexport {assembleShaders} from './lib/assemble-shaders';\n\n// HELPERS\nexport {combineInjects} from './lib/inject-shader';\nexport {normalizeShaderModule} from './lib/shader-module';\n\n// UTILS\nexport {\n getQualifierDetails,\n getPassthroughFS,\n typeToChannelSuffix,\n typeToChannelCount,\n convertToVec4\n} from './utils/shader-utils';\n\n// SHADER MODULES\nexport * from './modules';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA;;AAGA;;AACA;;AAGA;;AASA;;AAAA;EAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA"}

package/dist/es5/lib/assemble-shaders.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../../../src/lib/assemble-shaders.js"],"names":["INJECT_SHADER_DECLARATIONS","DECLARATION_INJECT_MARKER","SHADER_TYPE","VERTEX_SHADER","FRAGMENT_SHADER","FRAGMENT_SHADER_PROLOGUE","assembleShaders","gl","opts","vs","fs","modules","assembleShader","Object","assign","source","type","getUniforms","assembleGetUniforms","id","defines","hookFunctions","inject","transpileToGLSL100","prologue","log","isVertex","sourceLines","split","glslVersion","versionLine","coreSource","indexOf","slice","join","allDefines","forEach","module","getDefines","assembledSource","getShaderName","getShaderType","getApplicationDefines","hookFunctionMap","normalizeHookFunctions","hookInjections","declInjections","mainInjections","key","injection","order","match","hash","name","checkDeprecations","moduleSource","getModuleSource","injections","injectionType","push","getHookFunctions","uniforms","moduleUniforms","toUpperCase","injectShaderName","count","sourceText","define","value","Number","isFinite","result","hookName","hookFunction","signature","header","sort","a","b","footer","hook","trim","stage","replace"],"mappings":"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","sourcesContent":["import {VERTEX_SHADER, FRAGMENT_SHADER} from './constants';\nimport {resolveModules} from './resolve-modules';\nimport {getPlatformShaderDefines, getVersionDefines} from './platform-defines';\nimport injectShader, {DECLARATION_INJECT_MARKER} from './inject-shader';\nimport transpileShader from './transpile-shader';\nimport {assert} from '../utils';\n\nconst INJECT_SHADER_DECLARATIONS = `\\n\\n${DECLARATION_INJECT_MARKER}\\n\\n`;\n\nconst SHADER_TYPE = {\n [VERTEX_SHADER]: 'vertex',\n [FRAGMENT_SHADER]: 'fragment'\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...\nconst FRAGMENT_SHADER_PROLOGUE = `\\\nprecision highp float;\n\n`;\n\n// Inject a list of modules\nexport function assembleShaders(gl, opts) {\n const {vs, fs} = opts;\n const modules = resolveModules(opts.modules \|\| []);\n return {\n gl,\n vs: assembleShader(gl, Object.assign({}, opts, {source: vs, type: VERTEX_SHADER, modules})),\n fs: assembleShader(gl, Object.assign({}, opts, {source: fs, type: FRAGMENT_SHADER, modules})),\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.\nfunction assembleShader(\n gl,\n {\n id,\n source,\n type,\n modules,\n defines = {},\n hookFunctions = [],\n inject = {},\n transpileToGLSL100 = false,\n prologue = true,\n log\n }\n) {\n assert(typeof source === 'string', 'shader source must be a string');\n\n const isVertex = type === VERTEX_SHADER;\n\n const sourceLines = source.split('\\n');\n let glslVersion = 100;\n let versionLine = '';\n let coreSource = source;\n // Extract any version directive string from source.\n // TODO : keep all pre-processor statements at the begining of the shader.\n if (sourceLines[0].indexOf('#version ') === 0) {\n glslVersion = 300; // TODO - regexp that matches actual version number\n versionLine = sourceLines[0];\n coreSource = sourceLines.slice(1).join('\\n');\n } else {\n versionLine = `#version ${glslVersion}`;\n }\n\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\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 = prologue\n ? `\\\n${versionLine}\n${getShaderName({id, source, type})}\n${getShaderType({type})}\n${getPlatformShaderDefines(gl)}\n${getVersionDefines(gl, glslVersion, !isVertex)}\n${getApplicationDefines(allDefines)}\n${isVertex ? '' : FRAGMENT_SHADER_PROLOGUE}\n`\n : `${versionLine}\n`;\n\n const hookFunctionMap = normalizeHookFunctions(hookFunctions);\n\n // Add source of dependent modules in resolved order\n const hookInjections = {};\n const declInjections = {};\n const mainInjections = {};\n\n for (const key in inject) {\n const injection =\n typeof inject[key] === 'string' ? {injection: inject[key], order: 0} : inject[key];\n const match = key.match(/^(v\|f)s:(#)?([\\w-]+)$/);\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 } else {\n mainInjections[key] = [injection];\n }\n } else {\n hookInjections[key] = [injection];\n }\n } else {\n // Regex injection\n mainInjections[key] = [injection];\n }\n }\n\n for (const module of modules) {\n if (log) {\n module.checkDeprecations(coreSource, log);\n }\n const moduleSource = module.getModuleSource(type, glslVersion);\n // Add the module source, and a #define that declares it presence\n assembledSource += moduleSource;\n\n const injections = module.injections[type];\n for (const key in injections) {\n const match = key.match(/^(v\|f)s:#([\\w-]+)$/);\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 } else {\n hookInjections[key] = hookInjections[key] \|\| [];\n hookInjections[key].push(injections[key]);\n }\n }\n }\n\n // For injectShader\n assembledSource += INJECT_SHADER_DECLARATIONS;\n\n assembledSource = injectShader(assembledSource, type, declInjections);\n\n assembledSource += getHookFunctions(hookFunctionMap[type], hookInjections);\n\n // Add the version directive and actual source of this shader\n assembledSource += coreSource;\n\n // Apply any requested shader injections\n assembledSource = injectShader(assembledSource, type, mainInjections);\n\n assembledSource = transpileShader(\n assembledSource,\n transpileToGLSL100 ? 100 : glslVersion,\n isVertex\n );\n\n return assembledSource;\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.\nfunction 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\nfunction getShaderType({type}) {\n return `\n#define SHADER_TYPE_${SHADER_TYPE[type].toUpperCase()}\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\nfunction getShaderName({id, source, type}) {\n const injectShaderName = id && typeof id === 'string' && source.indexOf('SHADER_NAME') === -1;\n return injectShaderName\n ? `\n#define SHADER_NAME ${id}_${SHADER_TYPE[type]}\n\n`\n : '';\n}\n\n// Generates application defines from an object\nfunction getApplicationDefines(defines = {}) {\n let count = 0;\n let sourceText = '';\n for (const define in defines) {\n if (count === 0) {\n sourceText += '\\n// APPLICATION DEFINES\\n';\n }\n count++;\n\n const value = defines[define];\n if (value \|\| Number.isFinite(value)) {\n sourceText += `#define ${define.toUpperCase()} ${defines[define]}\\n`;\n }\n }\n if (count === 0) {\n sourceText += '\\n';\n }\n return sourceText;\n}\n\nfunction getHookFunctions(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\n return result;\n}\n\nfunction normalizeHookFunctions(hookFunctions) {\n const result = {\n vs: {},\n fs: {}\n };\n\n hookFunctions.forEach(hook => {\n let opts;\n if (typeof hook !== 'string') {\n opts = hook;\n hook = opts.hook;\n } else {\n opts = {};\n }\n hook = hook.trim();\n const [stage, signature] = hook.split(':');\n const name = hook.replace(/\\(.+/, '');\n result[stage][name] = Object.assign(opts, {signature});\n });\n\n return result;\n}\n"],"file":"assemble-shaders.js"}
1	+ {"version":3,"file":"assemble-shaders.js","names":["INJECT_SHADER_DECLARATIONS","DECLARATION_INJECT_MARKER","SHADER_TYPE","VERTEX_SHADER","FRAGMENT_SHADER","FRAGMENT_SHADER_PROLOGUE","assembleShaders","gl","opts","vs","fs","modules","resolveModules","assembleShader","Object","assign","source","type","getUniforms","assembleGetUniforms","id","defines","hookFunctions","inject","transpileToGLSL100","prologue","log","assert","isVertex","sourceLines","split","glslVersion","versionLine","coreSource","indexOf","slice","join","allDefines","forEach","module","getDefines","assembledSource","getShaderName","getShaderType","getPlatformShaderDefines","getVersionDefines","getApplicationDefines","hookFunctionMap","normalizeHookFunctions","hookInjections","declInjections","mainInjections","key","injection","order","match","hash","name","checkDeprecations","moduleSource","getModuleSource","injections","injectionType","push","injectShader","getHookFunctions","transpileShader","uniforms","moduleUniforms","toUpperCase","injectShaderName","count","sourceText","define","value","Number","isFinite","result","hookName","hookFunction","signature","header","sort","a","b","footer","hook","trim","stage","replace"],"sources":["../../../src/lib/assemble-shaders.js"],"sourcesContent":["import {VERTEX_SHADER, FRAGMENT_SHADER} from './constants';\nimport {resolveModules} from './resolve-modules';\nimport {getPlatformShaderDefines, getVersionDefines} from './platform-defines';\nimport injectShader, {DECLARATION_INJECT_MARKER} from './inject-shader';\nimport transpileShader from './transpile-shader';\nimport {assert} from '../utils';\n\nconst INJECT_SHADER_DECLARATIONS = `\\n\\n${DECLARATION_INJECT_MARKER}\\n\\n`;\n\nconst SHADER_TYPE = {\n [VERTEX_SHADER]: 'vertex',\n [FRAGMENT_SHADER]: 'fragment'\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...\nconst FRAGMENT_SHADER_PROLOGUE = `\\\nprecision highp float;\n\n`;\n\n// Inject a list of modules\nexport function assembleShaders(gl, opts) {\n const {vs, fs} = opts;\n const modules = resolveModules(opts.modules \|\| []);\n return {\n gl,\n vs: assembleShader(gl, Object.assign({}, opts, {source: vs, type: VERTEX_SHADER, modules})),\n fs: assembleShader(gl, Object.assign({}, opts, {source: fs, type: FRAGMENT_SHADER, modules})),\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.\nfunction assembleShader(\n gl,\n {\n id,\n source,\n type,\n modules,\n defines = {},\n hookFunctions = [],\n inject = {},\n transpileToGLSL100 = false,\n prologue = true,\n log\n }\n) {\n assert(typeof source === 'string', 'shader source must be a string');\n\n const isVertex = type === VERTEX_SHADER;\n\n const sourceLines = source.split('\\n');\n let glslVersion = 100;\n let versionLine = '';\n let coreSource = source;\n // Extract any version directive string from source.\n // TODO : keep all pre-processor statements at the begining of the shader.\n if (sourceLines[0].indexOf('#version ') === 0) {\n glslVersion = 300; // TODO - regexp that matches actual version number\n versionLine = sourceLines[0];\n coreSource = sourceLines.slice(1).join('\\n');\n } else {\n versionLine = `#version ${glslVersion}`;\n }\n\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\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 = prologue\n ? `\\\n${versionLine}\n${getShaderName({id, source, type})}\n${getShaderType({type})}\n${getPlatformShaderDefines(gl)}\n${getVersionDefines(gl, glslVersion, !isVertex)}\n${getApplicationDefines(allDefines)}\n${isVertex ? '' : FRAGMENT_SHADER_PROLOGUE}\n`\n : `${versionLine}\n`;\n\n const hookFunctionMap = normalizeHookFunctions(hookFunctions);\n\n // Add source of dependent modules in resolved order\n const hookInjections = {};\n const declInjections = {};\n const mainInjections = {};\n\n for (const key in inject) {\n const injection =\n typeof inject[key] === 'string' ? {injection: inject[key], order: 0} : inject[key];\n const match = key.match(/^(v\|f)s:(#)?([\\w-]+)$/);\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 } else {\n mainInjections[key] = [injection];\n }\n } else {\n hookInjections[key] = [injection];\n }\n } else {\n // Regex injection\n mainInjections[key] = [injection];\n }\n }\n\n for (const module of modules) {\n if (log) {\n module.checkDeprecations(coreSource, log);\n }\n const moduleSource = module.getModuleSource(type, glslVersion);\n // Add the module source, and a #define that declares it presence\n assembledSource += moduleSource;\n\n const injections = module.injections[type];\n for (const key in injections) {\n const match = key.match(/^(v\|f)s:#([\\w-]+)$/);\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 } else {\n hookInjections[key] = hookInjections[key] \|\| [];\n hookInjections[key].push(injections[key]);\n }\n }\n }\n\n // For injectShader\n assembledSource += INJECT_SHADER_DECLARATIONS;\n\n assembledSource = injectShader(assembledSource, type, declInjections);\n\n assembledSource += getHookFunctions(hookFunctionMap[type], hookInjections);\n\n // Add the version directive and actual source of this shader\n assembledSource += coreSource;\n\n // Apply any requested shader injections\n assembledSource = injectShader(assembledSource, type, mainInjections);\n\n assembledSource = transpileShader(\n assembledSource,\n transpileToGLSL100 ? 100 : glslVersion,\n isVertex\n );\n\n return assembledSource;\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.\nfunction 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\nfunction getShaderType({type}) {\n return `\n#define SHADER_TYPE_${SHADER_TYPE[type].toUpperCase()}\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\nfunction getShaderName({id, source, type}) {\n const injectShaderName = id && typeof id === 'string' && source.indexOf('SHADER_NAME') === -1;\n return injectShaderName\n ? `\n#define SHADER_NAME ${id}_${SHADER_TYPE[type]}\n\n`\n : '';\n}\n\n// Generates application defines from an object\nfunction getApplicationDefines(defines = {}) {\n let count = 0;\n let sourceText = '';\n for (const define in defines) {\n if (count === 0) {\n sourceText += '\\n// APPLICATION DEFINES\\n';\n }\n count++;\n\n const value = defines[define];\n if (value \|\| Number.isFinite(value)) {\n sourceText += `#define ${define.toUpperCase()} ${defines[define]}\\n`;\n }\n }\n if (count === 0) {\n sourceText += '\\n';\n }\n return sourceText;\n}\n\nfunction getHookFunctions(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\n return result;\n}\n\nfunction normalizeHookFunctions(hookFunctions) {\n const result = {\n vs: {},\n fs: {}\n };\n\n hookFunctions.forEach(hook => {\n let opts;\n if (typeof hook !== 'string') {\n opts = hook;\n hook = opts.hook;\n } else {\n opts = {};\n }\n hook = hook.trim();\n const [stage, signature] = hook.split(':');\n const name = hook.replace(/\\(.+/, '');\n result[stage][name] = Object.assign(opts, {signature});\n });\n\n return result;\n}\n"],"mappings":"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"}

package/dist/es5/lib/constants.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"~~sources~~":["~~../../../src/lib/~~constants.js"],"names":["VERTEX_SHADER","FRAGMENT_SHADER"],"~~mappings~~":"~~;;;;;;AAAO,IAAMA,aAAa,GAAG,IAAtB;;AACA,IAAMC,eAAe,GAAG,IAAxB~~","sourcesContent":["export const VERTEX_SHADER = 'vs';\nexport const FRAGMENT_SHADER = 'fs';\n"],"~~file~~":"~~constants.js~~"}
1	+ {"version":3,"file":"constants.js","names":["VERTEX_SHADER","FRAGMENT_SHADER"],"sources":["../../../src/lib/constants.js"],"sourcesContent":["export const VERTEX_SHADER = 'vs';\nexport const FRAGMENT_SHADER = 'fs';\n"],"mappings":";;;;;;AAAO,IAAMA,aAAa,GAAG,IAAtB;;AACA,IAAMC,eAAe,GAAG,IAAxB"}

package/dist/es5/lib/filters/prop-types.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"~~sources~~":["~~../../../../src/lib/filters/~~prop-types.js"],"names":["TYPE_DEFINITIONS","number","validate","value","propType","Number","isFinite","max","min","array","Array","isArray","ArrayBuffer","isView","parsePropTypes","propDefs","propTypes","propName","propDef","parsePropType","type","getTypeOf","Object","assign"],"~~mappings~~":";;;;;;;;;;;AAAA,IAAMA,gBAAgB,GAAG;AACvBC,EAAAA,MAAM,EAAE;AACNC,IAAAA,QADM,oBACGC,KADH,EACUC,QADV,EACoB;AACxB,aACEC,MAAM,CAACC,QAAP,CAAgBH,KAAhB,MACC,EAAE,SAASC,QAAX,KAAwBD,KAAK,IAAIC,QAAQ,CAACG,GAD3C,MAEC,EAAE,SAASH,QAAX,KAAwBD,KAAK,IAAIC,QAAQ,CAACI,GAF3C,CADF;AAKD;AAPK,GADe;AAUvBC,EAAAA,KAAK,EAAE;AACLP,IAAAA,QADK,oBACIC,KADJ,EACWC,QADX,EACqB;AACxB,aAAOM,KAAK,CAACC,OAAN,CAAcR,KAAd,KAAwBS,WAAW,CAACC,MAAZ,CAAmBV,KAAnB,CAA/~~B;AACD;AAHI;AAVgB,CAAzB;;AAiBO,SAASW,cAAT,CAAwBC,QAAxB,EAAkC;AACvC,MAAMC,SAAS,GAAG,EAAlB;;AACA,OAAK,IAAMC,QAAX,IAAuBF,QAAvB,EAAiC;AAC~~/B,QAAMG,OAAO,GAAGH,QAAQ,CAACE,QAAD,CAAxB;AACA,QAAMb,QAAQ,GAAGe,aAAa,CAACD,OAAD,CAA9B;AACAF,IAAAA,SAAS,CAACC,QAAD,CAAT,GAAsBb,QAAtB;AACD;;AACD,SAAOY,SAAP;AACD;;AAKD,SAASG,aAAT,CAAuBD,OAAvB,EAAgC;AAC9B,MAAIE,IAAI,GAAGC,SAAS,CAACH,OAAD,CAApB;;AACA,MAAIE,IAAI,KAAK,QAAb,EAAuB;AACrB,QAAI,CAACF,OAAL,EAAc;AACZ,aAAO;AAACE,QAAAA,IAAI,EAAE,QAAP;AAAiBjB,QAAAA,KAAK,EAAE;AAAxB,OAAP;AACD;;AACD,QAAI,UAAUe,OAAd,EAAuB;AACrB,aAAOI,MAAM,CAACC,MAAP,CAAc,EAAd,EAAkBL,OAAlB,EAA2BlB,gBAAgB,CAACkB,OAAO,CAACE,IAAT,CAA3C,CAAP;AACD;;AACD,QAAI,EAAE,WAAWF,OAAb,CAAJ,EAA2B;AAEzB,aAAO;AAACE,QAAAA,IAAI,EAAE,QAAP;AAAiBjB,QAAAA,KAAK,EAAEe;AAAxB,OAAP;AACD;;AACDE,IAAAA,IAAI,GAAGC,SAAS,CAACH,OAAO,CAACf,KAAT,CAAhB;AACA,WAAOmB,MAAM,CAACC,MAAP,CAAc;AAACH,MAAAA,IAAI,EAAJA;AAAD,KAAd,EAAsBF,OAAtB,EAA+BlB,gBAAgB,CAACoB,IAAD,CAA/C,CAAP;AACD;;AACD,SAAOE,MAAM,CAACC,MAAP,CAAc;AAACH,IAAAA,IAAI,EAAJA,IAAD;AAAOjB,IAAAA,KAAK,EAAEe;AAAd,GAAd,EAAsClB,gBAAgB,CAACoB,IAAD,CAAtD,CAAP;AACD;;AAGD,SAASC,SAAT,CAAmBlB,KAAnB,EAA0B;AACxB,MAAIO,KAAK,CAACC,OAAN,CAAcR,KAAd,KAAwBS,WAAW,CAACC,MAAZ,CAAmBV,KAAnB,CAA5B,EAAuD;AACrD,WAAO,OAAP;AACD;;AACD,+BAAcA,KAAd;AACD","sourcesContent":["const TYPE_DEFINITIONS = {\n number: {\n validate(value, propType) {\n return (\n Number.isFinite(value) &&\n (!('max' in propType) \|\| value <= propType.max) &&\n (!('min' in propType) \|\| value >= propType.min)\n );\n }\n },\n array: {\n validate(value, propType) {\n return Array.isArray(value) \|\| ArrayBuffer.isView(value);\n }\n }\n};\n\nexport function parsePropTypes(propDefs) {\n const propTypes = {};\n for (const propName in propDefs) {\n const propDef = propDefs[propName];\n const propType = parsePropType(propDef);\n propTypes[propName] = propType;\n }\n return propTypes;\n}\n\n// Parses one property definition entry. Either contains:\n// * a valid prop type object ({type, ...})\n// * or just a default value, in which case type and name inference is used\nfunction parsePropType(propDef) {\n let type = getTypeOf(propDef);\n if (type === 'object') {\n if (!propDef) {\n return {type: 'object', value: null};\n }\n if ('type' in propDef) {\n return Object.assign({}, propDef, TYPE_DEFINITIONS[propDef.type]);\n }\n if (!('value' in propDef)) {\n // If no type and value this object is likely the value\n return {type: 'object', value: propDef};\n }\n type = getTypeOf(propDef.value);\n return Object.assign({type}, propDef, TYPE_DEFINITIONS[type]);\n }\n return Object.assign({type, value: propDef}, TYPE_DEFINITIONS[type]);\n}\n\n// improved version of javascript typeof that can distinguish arrays and null values\nfunction getTypeOf(value) {\n if (Array.isArray(value) \|\| ArrayBuffer.isView(value)) {\n return 'array';\n }\n return typeof value;\n}\n"],"~~file~~":"~~prop-types.js~~"}
1	+ {"version":3,"file":"prop-types.js","names":["TYPE_DEFINITIONS","number","validate","value","propType","Number","isFinite","max","min","array","Array","isArray","ArrayBuffer","isView","parsePropTypes","propDefs","propTypes","propName","propDef","parsePropType","type","getTypeOf","Object","assign"],"sources":["../../../../src/lib/filters/prop-types.js"],"sourcesContent":["const TYPE_DEFINITIONS = {\n number: {\n validate(value, propType) {\n return (\n Number.isFinite(value) &&\n (!('max' in propType) \|\| value <= propType.max) &&\n (!('min' in propType) \|\| value >= propType.min)\n );\n }\n },\n array: {\n validate(value, propType) {\n return Array.isArray(value) \|\| ArrayBuffer.isView(value);\n }\n }\n};\n\nexport function parsePropTypes(propDefs) {\n const propTypes = {};\n for (const propName in propDefs) {\n const propDef = propDefs[propName];\n const propType = parsePropType(propDef);\n propTypes[propName] = propType;\n }\n return propTypes;\n}\n\n// Parses one property definition entry. Either contains:\n// * a valid prop type object ({type, ...})\n// * or just a default value, in which case type and name inference is used\nfunction parsePropType(propDef) {\n let type = getTypeOf(propDef);\n if (type === 'object') {\n if (!propDef) {\n return {type: 'object', value: null};\n }\n if ('type' in propDef) {\n return Object.assign({}, propDef, TYPE_DEFINITIONS[propDef.type]);\n }\n if (!('value' in propDef)) {\n // If no type and value this object is likely the value\n return {type: 'object', value: propDef};\n }\n type = getTypeOf(propDef.value);\n return Object.assign({type}, propDef, TYPE_DEFINITIONS[type]);\n }\n return Object.assign({type, value: propDef}, TYPE_DEFINITIONS[type]);\n}\n\n// improved version of javascript typeof that can distinguish arrays and null values\nfunction getTypeOf(value) {\n if (Array.isArray(value) \|\| ArrayBuffer.isView(value)) {\n return 'array';\n }\n return typeof value;\n}\n"],"mappings":";;;;;;;;;;;AAAA,IAAMA,gBAAgB,GAAG;EACvBC,MAAM,EAAE;IACNC,QADM,oBACGC,KADH,EACUC,QADV,EACoB;MACxB,OACEC,MAAM,CAACC,QAAP,CAAgBH,KAAhB,MACC,EAAE,SAASC,QAAX,KAAwBD,KAAK,IAAIC,QAAQ,CAACG,GAD3C,MAEC,EAAE,SAASH,QAAX,KAAwBD,KAAK,IAAIC,QAAQ,CAACI,GAF3C,CADF;IAKD;EAPK,CADe;EAUvBC,KAAK,EAAE;IACLP,QADK,oBACIC,KADJ,EACWC,QADX,EACqB;MACxB,OAAOM,KAAK,CAACC,OAAN,CAAcR,KAAd,KAAwBS,WAAW,CAACC,MAAZ,CAAmBV,KAAnB,CAA/B;IACD;EAHI;AAVgB,CAAzB;;AAiBO,SAASW,cAAT,CAAwBC,QAAxB,EAAkC;EACvC,IAAMC,SAAS,GAAG,EAAlB;;EACA,KAAK,IAAMC,QAAX,IAAuBF,QAAvB,EAAiC;IAC/B,IAAMG,OAAO,GAAGH,QAAQ,CAACE,QAAD,CAAxB;IACA,IAAMb,QAAQ,GAAGe,aAAa,CAACD,OAAD,CAA9B;IACAF,SAAS,CAACC,QAAD,CAAT,GAAsBb,QAAtB;EACD;;EACD,OAAOY,SAAP;AACD;;AAKD,SAASG,aAAT,CAAuBD,OAAvB,EAAgC;EAC9B,IAAIE,IAAI,GAAGC,SAAS,CAACH,OAAD,CAApB;;EACA,IAAIE,IAAI,KAAK,QAAb,EAAuB;IACrB,IAAI,CAACF,OAAL,EAAc;MACZ,OAAO;QAACE,IAAI,EAAE,QAAP;QAAiBjB,KAAK,EAAE;MAAxB,CAAP;IACD;;IACD,IAAI,UAAUe,OAAd,EAAuB;MACrB,OAAOI,MAAM,CAACC,MAAP,CAAc,EAAd,EAAkBL,OAAlB,EAA2BlB,gBAAgB,CAACkB,OAAO,CAACE,IAAT,CAA3C,CAAP;IACD;;IACD,IAAI,EAAE,WAAWF,OAAb,CAAJ,EAA2B;MAEzB,OAAO;QAACE,IAAI,EAAE,QAAP;QAAiBjB,KAAK,EAAEe;MAAxB,CAAP;IACD;;IACDE,IAAI,GAAGC,SAAS,CAACH,OAAO,CAACf,KAAT,CAAhB;IACA,OAAOmB,MAAM,CAACC,MAAP,CAAc;MAACH,IAAI,EAAJA;IAAD,CAAd,EAAsBF,OAAtB,EAA+BlB,gBAAgB,CAACoB,IAAD,CAA/C,CAAP;EACD;;EACD,OAAOE,MAAM,CAACC,MAAP,CAAc;IAACH,IAAI,EAAJA,IAAD;IAAOjB,KAAK,EAAEe;EAAd,CAAd,EAAsClB,gBAAgB,CAACoB,IAAD,CAAtD,CAAP;AACD;;AAGD,SAASC,SAAT,CAAmBlB,KAAnB,EAA0B;EACxB,IAAIO,KAAK,CAACC,OAAN,CAAcR,KAAd,KAAwBS,WAAW,CAACC,MAAZ,CAAmBV,KAAnB,CAA5B,EAAuD;IACrD,OAAO,OAAP;EACD;;EACD,6BAAcA,KAAd;AACD"}

package/dist/es5/lib/inject-shader.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"~~sources~~":["~~../../../src/lib/~~inject-shader.js"],"names":["MODULE_INJECTORS","VERTEX_SHADER","MODULE_INJECTORS_VS","FRAGMENT_SHADER","MODULE_INJECTORS_FS","DECLARATION_INJECT_MARKER","REGEX_START_OF_MAIN","REGEX_END_OF_MAIN","fragments","injectShader","source","type","inject","injectStandardStubs","isVertex","key","fragmentData","sort","a","b","order","length","i","len","injection","fragmentString","join","replace","match","combineInjects","injects","result","Array","isArray","forEach"],"~~mappings~~":";;;;;;;;;;;;;AAAA;;AACA;;AACA;;;;AAGA,IAAMA,gBAAgB,6EACnBC,wBADmB,EACHC,oCADG,oDAEnBC,0BAFmB,EAEDC,oCAFC,qBAAtB;AAKO,IAAMC,yBAAyB,GAAG,8BAAlC;;AAEP,IAAMC,mBAAmB,GAAG,iCAA5B;AACA,IAAMC,iBAAiB,GAAG,aAA1B;AACA,IAAMC,SAAS,GAAG,EAAlB;;AAKe,SAASC,YAAT,CAAsBC,MAAtB,EAA8BC,IAA9B,EAAoCC,MAApC,EAAyE;AAAA,MAA7BC,mBAA6B,uEAAP,KAAO;AACtF,MAAMC,QAAQ,GAAGH,IAAI,KAAKV,wBAA1B;;AADsF,6BAG3Ec,GAH2E;AAIpF,QAAMC,YAAY,GAAGJ,MAAM,CAACG,GAAD,CAA3B;AACAC,IAAAA,YAAY,CAACC,IAAb,CAAkB,UAACC,CAAD,EAAIC,CAAJ;AAAA,aAAUD,CAAC,CAACE,KAAF,GAAUD,CAAC,CAACC,KAAtB;AAAA,KAAlB;AACAZ,IAAAA,SAAS,CAACa,MAAV,GAAmBL,YAAY,CAACK,MAAhC;;AACA,SAAK,IAAIC,CAAC,GAAG,CAAR,EAAWC,GAAG,GAAGP,YAAY,CAACK,MAAnC,EAA2CC,CAAC,GAAGC,GAA/~~C,EAAoD,EAAED,CAAtD,EAAyD;AACvDd,MAAAA,SAAS,CAACc,CAAD,CAAT,GAAeN,YAAY,CAACM,CAAD,CAAZ,CAAgBE,SAA~~/B;AACD;;AACD,QAAMC,cAAc,aAAMjB,SAAS,CAACkB,IAAV,CAAe,IAAf,CAAN,OAApB;;AACA,YAAQX,GAAR;AAEE,WAAK,UAAL;AACE,YAAID,QAAJ,EAAc;AACZJ,UAAAA,MAAM,GAAGA,MAAM,CAACiB,OAAP,CAAetB,yBAAf,EAA0CoB,cAA1C,CAAT;AACD;;AACD;;AAEF,WAAK,gBAAL;AACE,YAAIX,QAAJ,EAAc;AACZJ,UAAAA,MAAM,GAAGA,MAAM,CAACiB,OAAP,CAAerB,mBAAf,EAAoC,UAAAsB,KAAK;AAAA,mBAAIA,KAAK,GAAGH,cAAZ;AAAA,WAAzC,CAAT;AACD;;AACD;;AAEF,WAAK,cAAL;AACE,YAAIX,QAAJ,EAAc;AACZJ,UAAAA,MAAM,GAAGA,MAAM,CAACiB,OAAP,CAAepB,iBAAf,EAAkC,UAAAqB,KAAK;AAAA,mBAAIH,cAAc,GAAGG,KAArB;AAAA,WAAvC,CAAT;AACD;;AACD;;AAEF,WAAK,UAAL;AACE,YAAI,CAACd,QAAL,EAAe;AACbJ,UAAAA,MAAM,GAAGA,MAAM,CAACiB,OAAP,CAAetB,yBAAf,EAA0CoB,cAA1C,CAAT;AACD;;AACD;;AAEF,WAAK,gBAAL;AACE,YAAI,CAACX,QAAL,EAAe;AACbJ,UAAAA,MAAM,GAAGA,MAAM,CAACiB,OAAP,CAAerB,mBAAf,EAAoC,UAAAsB,KAAK;AAAA,mBAAIA,KAAK,GAAGH,cAAZ;AAAA,WAAzC,CAAT;AACD;;AACD;;AAEF,WAAK,cAAL;AACE,YAAI,CAACX,QAAL,EAAe;AACbJ,UAAAA,MAAM,GAAGA,MAAM,CAACiB,OAAP,CAAepB,iBAAf,EAAkC,UAAAqB,KAAK;AAAA,mBAAIH,cAAc,GAAGG,KAArB;AAAA,WAAvC,CAAT;AACD;;AACD;;AAEF;AAIElB,QAAAA,MAAM,GAAGA,MAAM,CAACiB,OAAP,CAAeZ,GAAf,EAAoB,UAAAa,KAAK;AAAA,iBAAIA,KAAK,GAAGH,cAAZ;AAAA,SAAzB,CAAT;AA1CJ;AAXoF;;AAGtF,OAAK,IAAMV,GAAX,IAAkBH,MAAlB,EAA0B;AAAA,UAAfG,GAAe;AAoDzB;;AAGDL,EAAAA,MAAM,GAAGA,MAAM,CAACiB,OAAP,CAAetB,yBAAf,EAA0C,EAA1C,CAAT;;AAGA,MAAIQ,mBAAJ,EAAyB;AACvBH,IAAAA,MAAM,GAAGA,MAAM,CAACiB,OAAP,CAAe,QAAf,EAAyB,UAAAC,KAAK;AAAA,aAAIA,KAAK,GAAG5B,gBAAgB,CAACW,IAAD,CAA5B;AAAA,KAA9B,CAAT;AACD;;AAED,SAAOD,MAAP;AACD;;AAKM,SAASmB,cAAT,CAAwBC,OAAxB,EAAiC;AACtC,MAAMC,MAAM,GAAG,EAAf;AACA,qBAAOC,KAAK,CAACC,OAAN,CAAcH,OAAd,KAA0BA,OAAO,CAACT,MAAR,GAAiB,CAAlD;AACAS,EAAAA,OAAO,CAACI,OAAR,CAAgB,UAAAtB,MAAM,EAAI;AACxB,SAAK,IAAMG,GAAX,IAAkBH,MAAlB,EAA0B;AACxBmB,MAAAA,MAAM,CAAChB,GAAD,CAAN,GAAcgB,MAAM,CAAChB,GAAD,CAAN,aAAiBgB,MAAM,CAAChB,GAAD,CAAvB,eAAiCH,MAAM,CAACG,GAAD,CAAvC,IAAiDH,MAAM,CAACG,GAAD,CAArE;AACD;AACF,GAJD;AAKA,SAAOgB,MAAP;AACD","sourcesContent":["import {MODULE_INJECTORS_VS, MODULE_INJECTORS_FS} from '../modules/module-injectors';\nimport {VERTEX_SHADER, FRAGMENT_SHADER} from './constants';\nimport {assert} from '../utils';\n\n// TODO - experimental\nconst MODULE_INJECTORS = {\n [VERTEX_SHADER]: MODULE_INJECTORS_VS,\n [FRAGMENT_SHADER]: MODULE_INJECTORS_FS\n};\n\nexport const DECLARATION_INJECT_MARKER = '__LUMA_INJECT_DECLARATIONS__'; // Uniform/attribute declarations\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 = [];\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/* eslint-disable complexity /\nexport default function injectShader(source, type, inject, injectStandardStubs = false) {\n const isVertex = type === VERTEX_SHADER;\n\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\n default:\n // TODO(Tarek): I think this usage should be deprecated.\n\n // inject code after key, leaving key in place\n source = source.replace(key, match => match + fragmentString);\n }\n }\n\n // Remove if it hasn't already been replaced\n source = source.replace(DECLARATION_INJECT_MARKER, '');\n\n // Finally, if requested, insert an automatic module injector chunk\n if (injectStandardStubs) {\n source = source.replace(/\\}\\s$/, match => match + MODULE_INJECTORS[type]);\n }\n\n return source;\n}\n\n/* eslint-enable complexity */\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"],"~~file~~":"~~inject-shader.js~~"}
1	+ {"version":3,"file":"inject-shader.js","names":["MODULE_INJECTORS","VERTEX_SHADER","MODULE_INJECTORS_VS","FRAGMENT_SHADER","MODULE_INJECTORS_FS","DECLARATION_INJECT_MARKER","REGEX_START_OF_MAIN","REGEX_END_OF_MAIN","fragments","injectShader","source","type","inject","injectStandardStubs","isVertex","key","fragmentData","sort","a","b","order","length","i","len","injection","fragmentString","join","replace","match","combineInjects","injects","result","assert","Array","isArray","forEach"],"sources":["../../../src/lib/inject-shader.js"],"sourcesContent":["import {MODULE_INJECTORS_VS, MODULE_INJECTORS_FS} from '../modules/module-injectors';\nimport {VERTEX_SHADER, FRAGMENT_SHADER} from './constants';\nimport {assert} from '../utils';\n\n// TODO - experimental\nconst MODULE_INJECTORS = {\n [VERTEX_SHADER]: MODULE_INJECTORS_VS,\n [FRAGMENT_SHADER]: MODULE_INJECTORS_FS\n};\n\nexport const DECLARATION_INJECT_MARKER = '__LUMA_INJECT_DECLARATIONS__'; // Uniform/attribute declarations\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 = [];\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/* eslint-disable complexity /\nexport default function injectShader(source, type, inject, injectStandardStubs = false) {\n const isVertex = type === VERTEX_SHADER;\n\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\n default:\n // TODO(Tarek): I think this usage should be deprecated.\n\n // inject code after key, leaving key in place\n source = source.replace(key, match => match + fragmentString);\n }\n }\n\n // Remove if it hasn't already been replaced\n source = source.replace(DECLARATION_INJECT_MARKER, '');\n\n // Finally, if requested, insert an automatic module injector chunk\n if (injectStandardStubs) {\n source = source.replace(/\\}\\s$/, match => match + MODULE_INJECTORS[type]);\n }\n\n return source;\n}\n\n/* eslint-enable complexity */\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"],"mappings":"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"}

package/dist/es5/lib/platform-defines.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"~~sources~~":["~~../../../src/lib/~~platform-defines.js"],"names":["getPlatformShaderDefines","gl","debugInfo","gpuVendor","toLowerCase","getVersionDefines","glslVersion","isFragment","versionDefines","FEATURES","GLSL_FRAG_DEPTH","GLSL_DERIVATIVES","GLSL_FRAG_DATA","behavior","GLSL_TEXTURE_LOD"],"~~mappings~~":";;;;;;;;AAAA;;AAEO,SAASA,wBAAT,CAAkCC,EAAlC,EAAsC;AAC3C,MAAMC,SAAS,GAAG,+BAAeD,EAAf,CAAlB;;AAEA,UAAQC,SAAS,CAACC,SAAV,CAAoBC,WAApB,EAAR;AACE,SAAK,QAAL;AACE;;AAMF,SAAK,OAAL;AACE;;AAUF,SAAK,KAAL;AAEE;;AAIF;AAIE;AA7BJ;AAuCD;;AAEM,SAASC,iBAAT,CAA2BJ,EAA3B,EAA+BK,WAA/B,EAA4CC,UAA5C,EAAwD;AAE7D,MAAIC,cAAc,gUAAlB;;AAiBA,MAAI,4BAAYP,EAAZ,EAAgBQ,oBAASC,eAAzB,CAAJ,EAA+C;AAC7CF,IAAAA,cAAc,2NAAd;AAUD;;AACD,MACE,4BAAYP,EAAZ,EAAgBQ,oBAASE,gBAAzB,KACA,wCAAwBV,EAAxB,EAA4BQ,oBAASE,gBAArC,CAFF,EAGE;AACAH,IAAAA,cAAc,qNAAd;AASD;;AACD,MACE,4BAAYP,EAAZ,EAAgBQ,oBAASG,cAAzB,KACA,wCAAwBX,EAAxB,EAA4BQ,oBAASG,cAArC,EAAqD;AAACC,IAAAA,QAAQ,EAAE;AAAX,GAArD,CAFF,EAGE;AACAL,IAAAA,cAAc,8LAAd;AASD;;AACD,MAAI,4BAAYP,EAAZ,EAAgBQ,oBAASK,gBAAzB,CAAJ,EAAgD;AAC9CN,IAAAA,cAAc,8MAAd;AAUD;;AACD,SAAOA,cAAP;AACD","sourcesContent":["import {getContextInfo, hasFeatures, canCompileGLGSExtension, FEATURES} from '../utils/webgl-info';\n\nexport function getPlatformShaderDefines(gl) {\n const debugInfo = getContextInfo(gl);\n\n switch (debugInfo.gpuVendor.toLowerCase()) {\n case 'nvidia':\n return `\\\n#define NVIDIA_GPU\n// Nvidia optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n`;\n\n case 'intel':\n return `\\\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\n case 'amd':\n // AMD Does not eliminate fp64 code\n return `\\\n#define AMD_GPU\n`;\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 `\\\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// 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 }\n}\n\nexport function getVersionDefines(gl, glslVersion, isFragment) {\n // Add shadertools defines to let shaders portably v1/v3 check for features\n let versionDefines = `\\\n#if (__VERSION__ > 120)\n\n# define FEATURE_GLSL_DERIVATIVES\n# define FEATURE_GLSL_DRAW_BUFFERS\n# define FEATURE_GLSL_FRAG_DEPTH\n# define FEATURE_GLSL_TEXTURE_LOD\n\n// DEPRECATED FLAGS, remove in v9\n# define FRAG_DEPTH\n# define DERIVATIVES\n# define DRAW_BUFFERS\n# define TEXTURE_LOD\n\n#endif // __VERSION\n`;\n\n if (hasFeatures(gl, FEATURES.GLSL_FRAG_DEPTH)) {\n versionDefines += `\\\n\n// FRAG_DEPTH => gl_FragDepth is available\n#ifdef GL_EXT_frag_depth\n#extension GL_EXT_frag_depth : enable\n# define FEATURE_GLSL_FRAG_DEPTH\n# define FRAG_DEPTH\n# define gl_FragDepth gl_FragDepthEXT\n#endif\n`;\n }\n if (\n hasFeatures(gl, FEATURES.GLSL_DERIVATIVES) &&\n canCompileGLGSExtension(gl, FEATURES.GLSL_DERIVATIVES)\n ) {\n versionDefines += `\\\n\n// DERIVATIVES => dxdF, dxdY and fwidth are available\n#ifdef GL_OES_standard_derivatives\n#extension GL_OES_standard_derivatives : enable\n# define FEATURE_GLSL_DERIVATIVES\n# define DERIVATIVES\n#endif\n`;\n }\n if (\n hasFeatures(gl, FEATURES.GLSL_FRAG_DATA) &&\n canCompileGLGSExtension(gl, FEATURES.GLSL_FRAG_DATA, {behavior: 'require'})\n ) {\n versionDefines += `\\\n\n// DRAW_BUFFERS => gl_FragData[] is available\n#ifdef GL_EXT_draw_buffers\n#extension GL_EXT_draw_buffers : require\n#define FEATURE_GLSL_DRAW_BUFFERS\n#define DRAW_BUFFERS\n#endif\n`;\n }\n if (hasFeatures(gl, FEATURES.GLSL_TEXTURE_LOD)) {\n versionDefines += `\\\n// TEXTURE_LOD => texture2DLod etc are available\n#ifdef GL_EXT_shader_texture_lod\n#extension GL_EXT_shader_texture_lod : enable\n\n# define FEATURE_GLSL_TEXTURE_LOD\n# define TEXTURE_LOD\n\n#endif\n`;\n }\n return versionDefines;\n}\n"],"~~file~~":"~~platform-defines.js~~"}
1	+ {"version":3,"file":"platform-defines.js","names":["getPlatformShaderDefines","gl","debugInfo","getContextInfo","gpuVendor","toLowerCase","getVersionDefines","glslVersion","isFragment","versionDefines","hasFeatures","FEATURES","GLSL_FRAG_DEPTH","GLSL_DERIVATIVES","canCompileGLGSExtension","GLSL_FRAG_DATA","behavior","GLSL_TEXTURE_LOD"],"sources":["../../../src/lib/platform-defines.js"],"sourcesContent":["import {getContextInfo, hasFeatures, canCompileGLGSExtension, FEATURES} from '../utils/webgl-info';\n\nexport function getPlatformShaderDefines(gl) {\n const debugInfo = getContextInfo(gl);\n\n switch (debugInfo.gpuVendor.toLowerCase()) {\n case 'nvidia':\n return `\\\n#define NVIDIA_GPU\n// Nvidia optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n`;\n\n case 'intel':\n return `\\\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\n case 'amd':\n // AMD Does not eliminate fp64 code\n return `\\\n#define AMD_GPU\n`;\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 `\\\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// 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 }\n}\n\nexport function getVersionDefines(gl, glslVersion, isFragment) {\n // Add shadertools defines to let shaders portably v1/v3 check for features\n let versionDefines = `\\\n#if (__VERSION__ > 120)\n\n# define FEATURE_GLSL_DERIVATIVES\n# define FEATURE_GLSL_DRAW_BUFFERS\n# define FEATURE_GLSL_FRAG_DEPTH\n# define FEATURE_GLSL_TEXTURE_LOD\n\n// DEPRECATED FLAGS, remove in v9\n# define FRAG_DEPTH\n# define DERIVATIVES\n# define DRAW_BUFFERS\n# define TEXTURE_LOD\n\n#endif // __VERSION\n`;\n\n if (hasFeatures(gl, FEATURES.GLSL_FRAG_DEPTH)) {\n versionDefines += `\\\n\n// FRAG_DEPTH => gl_FragDepth is available\n#ifdef GL_EXT_frag_depth\n#extension GL_EXT_frag_depth : enable\n# define FEATURE_GLSL_FRAG_DEPTH\n# define FRAG_DEPTH\n# define gl_FragDepth gl_FragDepthEXT\n#endif\n`;\n }\n if (\n hasFeatures(gl, FEATURES.GLSL_DERIVATIVES) &&\n canCompileGLGSExtension(gl, FEATURES.GLSL_DERIVATIVES)\n ) {\n versionDefines += `\\\n\n// DERIVATIVES => dxdF, dxdY and fwidth are available\n#ifdef GL_OES_standard_derivatives\n#extension GL_OES_standard_derivatives : enable\n# define FEATURE_GLSL_DERIVATIVES\n# define DERIVATIVES\n#endif\n`;\n }\n if (\n hasFeatures(gl, FEATURES.GLSL_FRAG_DATA) &&\n canCompileGLGSExtension(gl, FEATURES.GLSL_FRAG_DATA, {behavior: 'require'})\n ) {\n versionDefines += `\\\n\n// DRAW_BUFFERS => gl_FragData[] is available\n#ifdef GL_EXT_draw_buffers\n#extension GL_EXT_draw_buffers : require\n#define FEATURE_GLSL_DRAW_BUFFERS\n#define DRAW_BUFFERS\n#endif\n`;\n }\n if (hasFeatures(gl, FEATURES.GLSL_TEXTURE_LOD)) {\n versionDefines += `\\\n// TEXTURE_LOD => texture2DLod etc are available\n#ifdef GL_EXT_shader_texture_lod\n#extension GL_EXT_shader_texture_lod : enable\n\n# define FEATURE_GLSL_TEXTURE_LOD\n# define TEXTURE_LOD\n\n#endif\n`;\n }\n return versionDefines;\n}\n"],"mappings":";;;;;;;;AAAA;;AAEO,SAASA,wBAAT,CAAkCC,EAAlC,EAAsC;EAC3C,IAAMC,SAAS,GAAG,IAAAC,yBAAA,EAAeF,EAAf,CAAlB;;EAEA,QAAQC,SAAS,CAACE,SAAV,CAAoBC,WAApB,EAAR;IACE,KAAK,QAAL;MACE;;IAMF,KAAK,OAAL;MACE;;IAUF,KAAK,KAAL;MAEE;;IAIF;MAIE;EA7BJ;AAuCD;;AAEM,SAASC,iBAAT,CAA2BL,EAA3B,EAA+BM,WAA/B,EAA4CC,UAA5C,EAAwD;EAE7D,IAAIC,cAAc,gUAAlB;;EAiBA,IAAI,IAAAC,sBAAA,EAAYT,EAAZ,EAAgBU,mBAAA,CAASC,eAAzB,CAAJ,EAA+C;IAC7CH,cAAc,2NAAd;EAUD;;EACD,IACE,IAAAC,sBAAA,EAAYT,EAAZ,EAAgBU,mBAAA,CAASE,gBAAzB,KACA,IAAAC,kCAAA,EAAwBb,EAAxB,EAA4BU,mBAAA,CAASE,gBAArC,CAFF,EAGE;IACAJ,cAAc,qNAAd;EASD;;EACD,IACE,IAAAC,sBAAA,EAAYT,EAAZ,EAAgBU,mBAAA,CAASI,cAAzB,KACA,IAAAD,kCAAA,EAAwBb,EAAxB,EAA4BU,mBAAA,CAASI,cAArC,EAAqD;IAACC,QAAQ,EAAE;EAAX,CAArD,CAFF,EAGE;IACAP,cAAc,8LAAd;EASD;;EACD,IAAI,IAAAC,sBAAA,EAAYT,EAAZ,EAAgBU,mBAAA,CAASM,gBAAzB,CAAJ,EAAgD;IAC9CR,cAAc,8MAAd;EAUD;;EACD,OAAOA,cAAP;AACD"}

package/dist/es5/lib/resolve-modules.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"~~sources~~":["~~../../../src/lib/~~resolve-modules.js"],"names":["resolveModules","modules","getShaderDependencies","instantiateModules","moduleMap","moduleDepth","getDependencyGraph","level","Object","keys","sort","a","b","map","name","Error","module","undefined","dependencies","seen","ShaderModule","TEST_EXPORTS"],"~~mappings~~":"~~;;;;;;;;;;AAAA;;AACA;;;;;;;;AAGO,SAASA,cAAT,CAAwBC,OAAxB,EAAiC;AACtC,SAAOC,qBAAqB,CAACC,kBAAkB,CAACF,OAAD,CAAnB,CAA5B;AACD;;AAcD,SAASC,qBAAT,CAA+BD,OAA~~/~~B,EAAwC;AACtC,MAAMG,SAAS,GAAG,EAAlB;AACA,MAAMC,WAAW,GAAG,EAApB;AACAC,EAAAA,kBAAkB,CAAC;AAACL,IAAAA,OAAO,EAAPA,OAAD;AAAUM,IAAAA,KAAK,EAAE,CAAjB;AAAoBH,IAAAA,SAAS,EAATA,SAApB;AAA+BC,IAAAA,WAAW,EAAXA;AAA~~/B,GAAD,CAAlB;AAGA,SAAOG,MAAM,CAACC,IAAP,CAAYJ,WAAZ,EACJK,IADI,CACC,UAACC,CAAD,EAAIC,CAAJ;AAAA,WAAUP,WAAW,CAACO,CAAD,CAAX,GAAiBP,WAAW,CAACM,CAAD,CAAtC;AAAA,GADD,EAEJE,GAFI,CAEA,UAAAC,IAAI;AAAA,WAAIV,SAAS,CAACU,IAAD,CAAb;AAAA,GAFJ,CAAP;AAGD;;AAcD,SAASR,kBAAT,OAAsE;AAAA,MAAzCL,OAAyC,QAAzCA,OAAyC;AAAA,MAAhCM,KAAgC,QAAhCA,KAAgC;AAAA,MAAzBH,SAAyB,QAAzBA,SAAyB;AAAA,MAAdC,WAAc,QAAdA,WAAc;;AACpE,MAAIE,KAAK,IAAI,CAAb,EAAgB;AACd,UAAM,IAAIQ,KAAJ,CAAU,0CAAV,CAAN;AACD;;AAHmE,6CAM/Cd,OAN+C;AAAA;;AAAA;AAMpE,wDAA8B;AAAA,UAAnBe,MAAmB;AAC5BZ,MAAAA,SAAS,CAACY,MAAM,CAACF,IAAR,CAAT,GAAyBE,MAAzB;;AACA,UAAIX,WAAW,CAACW,MAAM,CAACF,IAAR,CAAX,KAA6BG,SAA7B,IAA0CZ,WAAW,CAACW,MAAM,CAACF,IAAR,CAAX,GAA2BP,KAAzE,EAAgF;AAC9EF,QAAAA,WAAW,CAACW,MAAM,CAACF,IAAR,CAAX,GAA2BP,KAA3B;AACD;AACF;AAXmE;AAAA;AAAA;AAAA;AAAA;;AAAA,8CAc/CN,OAd+C;AAAA;;AAAA;AAcpE,2DAA8B;AAAA,UAAnBe,OAAmB;;AAC5B,UAAIA,OAAM,CAACE,YAAX,EAAyB;AACvBZ,QAAAA,kBAAkB,CAAC;AAACL,UAAAA,OAAO,EAAEe,OAAM,CAACE,YAAjB;AAA+BX,UAAAA,KAAK,EAAEA,KAAK,GAAG,CAA9C;AAAiDH,UAAAA,SAAS,EAATA,SAAjD;AAA4DC,UAAAA,WAAW,EAAXA;AAA5D,SAAD,CAAlB;AACD;AACF;AAlBmE;AAAA;AAAA;AAAA;AAAA;AAmBrE;;AAED,SAASF,kBAAT,CAA4BF,OAA5B,EAAqCkB,IAArC,EAA2C;AACzC,SAAOlB,OAAO,CAACY,GAAR,CAAY,UAAAG,MAAM,EAAI;AAC3B,QAAIA,MAAM,YAAYI,qBAAtB,EAAoC;AAClC,aAAOJ,MAAP;AACD;;AAED,uBACE,OAAOA,MAAP,KAAkB,QADpB,2EAEoEA,MAFpE;AAIA,uBAAOA,MAAM,CAACF,IAAd,EAAoB,2BAApB;AAEAE,IAAAA,MAAM,GAAG,IAAII,qBAAJ,CAAiBJ,MAAjB,CAAT;AACAA,IAAAA,MAAM,CAACE,YAAP,GAAsBf,kBAAkB,CAACa,MAAM,CAACE,YAAR,CAAxC;AAEA,WAAOF,MAAP;AACD,GAfM,CAAP;AAgBD;;AAEM,IAAMK,YAAY,GAAG;AAC1BnB,EAAAA,qBAAqB,EAArBA,qBAD0B;AAE1BI,EAAAA,kBAAkB,EAAlBA;AAF0B,CAArB","sourcesContent":["import ShaderModule from './shader-module';\nimport {assert} from '../utils';\n\n// Instantiate shader modules and any dependencies resolve dependencies\nexport function resolveModules(modules) {\n return getShaderDependencies(instantiateModules(modules));\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 {String[]} modules - Array of modules (inline modules or module names)\n * @return {String[]} - Array of modules\n /\nfunction getShaderDependencies(modules) {\n const moduleMap = {};\n const moduleDepth = {};\n getDependencyGraph({modules, level: 0, moduleMap, moduleDepth});\n\n // Return a reverse sort so that dependencies come before the modules that use them\n return Object.keys(moduleDepth)\n .sort((a, b) => moduleDepth[b] - moduleDepth[a])\n .map(name => moduleMap[name]);\n}\n\n/\n Recursively checks module dpendencies to calculate dependency\n * level of each module.\n \n @param {object} options\n * @param {object[]} options.modules - Array of modules\n * @param {number} options.level - Current level\n * @param {object} options.moduleMap -\n * @param {object} options.moduleDepth - Current level\n * @return {object} - Map of module name to its level\n */\n// Adds another level of dependencies to the result map\nfunction getDependencyGraph({modules, level, moduleMap, moduleDepth}) {\n if (level >= 5) {\n throw new Error('Possible loop in shader dependency graph');\n }\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\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\nfunction instantiateModules(modules, seen) {\n return modules.map(module => {\n if (module instanceof ShaderModule) {\n return module;\n }\n\n assert(\n typeof module !== 'string',\n `Shader module use by name is deprecated. Import shader module '${module}' and use it directly.`\n );\n assert(module.name, 'shader module has no name');\n\n module = new ShaderModule(module);\n module.dependencies = instantiateModules(module.dependencies);\n\n return module;\n });\n}\n\nexport const TEST_EXPORTS = {\n getShaderDependencies,\n getDependencyGraph\n};\n"],"~~file~~":"~~resolve-modules.js~~"}
1	+ {"version":3,"file":"resolve-modules.js","names":["resolveModules","modules","getShaderDependencies","instantiateModules","moduleMap","moduleDepth","getDependencyGraph","level","Object","keys","sort","a","b","map","name","Error","module","undefined","dependencies","seen","ShaderModule","assert","TEST_EXPORTS"],"sources":["../../../src/lib/resolve-modules.js"],"sourcesContent":["import ShaderModule from './shader-module';\nimport {assert} from '../utils';\n\n// Instantiate shader modules and any dependencies resolve dependencies\nexport function resolveModules(modules) {\n return getShaderDependencies(instantiateModules(modules));\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 {String[]} modules - Array of modules (inline modules or module names)\n * @return {String[]} - Array of modules\n /\nfunction getShaderDependencies(modules) {\n const moduleMap = {};\n const moduleDepth = {};\n getDependencyGraph({modules, level: 0, moduleMap, moduleDepth});\n\n // Return a reverse sort so that dependencies come before the modules that use them\n return Object.keys(moduleDepth)\n .sort((a, b) => moduleDepth[b] - moduleDepth[a])\n .map(name => moduleMap[name]);\n}\n\n/\n Recursively checks module dpendencies to calculate dependency\n * level of each module.\n \n @param {object} options\n * @param {object[]} options.modules - Array of modules\n * @param {number} options.level - Current level\n * @param {object} options.moduleMap -\n * @param {object} options.moduleDepth - Current level\n * @return {object} - Map of module name to its level\n */\n// Adds another level of dependencies to the result map\nfunction getDependencyGraph({modules, level, moduleMap, moduleDepth}) {\n if (level >= 5) {\n throw new Error('Possible loop in shader dependency graph');\n }\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\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\nfunction instantiateModules(modules, seen) {\n return modules.map(module => {\n if (module instanceof ShaderModule) {\n return module;\n }\n\n assert(\n typeof module !== 'string',\n `Shader module use by name is deprecated. Import shader module '${module}' and use it directly.`\n );\n assert(module.name, 'shader module has no name');\n\n module = new ShaderModule(module);\n module.dependencies = instantiateModules(module.dependencies);\n\n return module;\n });\n}\n\nexport const TEST_EXPORTS = {\n getShaderDependencies,\n getDependencyGraph\n};\n"],"mappings":";;;;;;;;;;AAAA;;AACA;;;;;;;;AAGO,SAASA,cAAT,CAAwBC,OAAxB,EAAiC;EACtC,OAAOC,qBAAqB,CAACC,kBAAkB,CAACF,OAAD,CAAnB,CAA5B;AACD;;AAcD,SAASC,qBAAT,CAA+BD,OAA/B,EAAwC;EACtC,IAAMG,SAAS,GAAG,EAAlB;EACA,IAAMC,WAAW,GAAG,EAApB;EACAC,kBAAkB,CAAC;IAACL,OAAO,EAAPA,OAAD;IAAUM,KAAK,EAAE,CAAjB;IAAoBH,SAAS,EAATA,SAApB;IAA+BC,WAAW,EAAXA;EAA/B,CAAD,CAAlB;EAGA,OAAOG,MAAM,CAACC,IAAP,CAAYJ,WAAZ,EACJK,IADI,CACC,UAACC,CAAD,EAAIC,CAAJ;IAAA,OAAUP,WAAW,CAACO,CAAD,CAAX,GAAiBP,WAAW,CAACM,CAAD,CAAtC;EAAA,CADD,EAEJE,GAFI,CAEA,UAAAC,IAAI;IAAA,OAAIV,SAAS,CAACU,IAAD,CAAb;EAAA,CAFJ,CAAP;AAGD;;AAcD,SAASR,kBAAT,OAAsE;EAAA,IAAzCL,OAAyC,QAAzCA,OAAyC;EAAA,IAAhCM,KAAgC,QAAhCA,KAAgC;EAAA,IAAzBH,SAAyB,QAAzBA,SAAyB;EAAA,IAAdC,WAAc,QAAdA,WAAc;;EACpE,IAAIE,KAAK,IAAI,CAAb,EAAgB;IACd,MAAM,IAAIQ,KAAJ,CAAU,0CAAV,CAAN;EACD;;EAHmE,2CAM/Cd,OAN+C;EAAA;;EAAA;IAMpE,oDAA8B;MAAA,IAAnBe,MAAmB;MAC5BZ,SAAS,CAACY,MAAM,CAACF,IAAR,CAAT,GAAyBE,MAAzB;;MACA,IAAIX,WAAW,CAACW,MAAM,CAACF,IAAR,CAAX,KAA6BG,SAA7B,IAA0CZ,WAAW,CAACW,MAAM,CAACF,IAAR,CAAX,GAA2BP,KAAzE,EAAgF;QAC9EF,WAAW,CAACW,MAAM,CAACF,IAAR,CAAX,GAA2BP,KAA3B;MACD;IACF;EAXmE;IAAA;EAAA;IAAA;EAAA;;EAAA,4CAc/CN,OAd+C;EAAA;;EAAA;IAcpE,uDAA8B;MAAA,IAAnBe,OAAmB;;MAC5B,IAAIA,OAAM,CAACE,YAAX,EAAyB;QACvBZ,kBAAkB,CAAC;UAACL,OAAO,EAAEe,OAAM,CAACE,YAAjB;UAA+BX,KAAK,EAAEA,KAAK,GAAG,CAA9C;UAAiDH,SAAS,EAATA,SAAjD;UAA4DC,WAAW,EAAXA;QAA5D,CAAD,CAAlB;MACD;IACF;EAlBmE;IAAA;EAAA;IAAA;EAAA;AAmBrE;;AAED,SAASF,kBAAT,CAA4BF,OAA5B,EAAqCkB,IAArC,EAA2C;EACzC,OAAOlB,OAAO,CAACY,GAAR,CAAY,UAAAG,MAAM,EAAI;IAC3B,IAAIA,MAAM,YAAYI,qBAAtB,EAAoC;MAClC,OAAOJ,MAAP;IACD;;IAED,IAAAK,aAAA,EACE,OAAOL,MAAP,KAAkB,QADpB,2EAEoEA,MAFpE;IAIA,IAAAK,aAAA,EAAOL,MAAM,CAACF,IAAd,EAAoB,2BAApB;IAEAE,MAAM,GAAG,IAAII,qBAAJ,CAAiBJ,MAAjB,CAAT;IACAA,MAAM,CAACE,YAAP,GAAsBf,kBAAkB,CAACa,MAAM,CAACE,YAAR,CAAxC;IAEA,OAAOF,MAAP;EACD,CAfM,CAAP;AAgBD;;AAEM,IAAMM,YAAY,GAAG;EAC1BpB,qBAAqB,EAArBA,qBAD0B;EAE1BI,kBAAkB,EAAlBA;AAF0B,CAArB"}

package/dist/es5/lib/shader-module.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"~~sources~~":["~~../../../src/lib/~~shader-module.js"],"names":["VERTEX_SHADER","FRAGMENT_SHADER","ShaderModule","name","vs","fs","dependencies","uniforms","getUniforms","deprecations","defines","inject","vertexShader","fragmentShader","getModuleUniforms","_parseDeprecationDefinitions","injections","normalizeInjections","type","moduleSource","toUpperCase","replace","opts","_defaultGetUniforms","shaderSource","log","forEach","def","regex","test","deprecated","old","new","removed","RegExp","propTypes","key","propDef","private","validate","value","normalizeShaderModule","module","normalized","shaderModule","bind","result","hook","injection","stage","slice","order"],"~~mappings~~":"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","sourcesContent":["import {assert} from '../utils';\nimport {parsePropTypes} from './filters/prop-types';\n\nconst VERTEX_SHADER = 'vs';\nconst FRAGMENT_SHADER = 'fs';\n\nexport default class ShaderModule {\n constructor({\n name,\n vs,\n fs,\n dependencies = [],\n uniforms,\n getUniforms,\n deprecations = [],\n defines = {},\n inject = {},\n // DEPRECATED\n vertexShader,\n fragmentShader\n }) {\n assert(typeof name === 'string');\n this.name = name;\n this.vs = vs \|\| vertexShader;\n this.fs = fs \|\| fragmentShader;\n this.getModuleUniforms = getUniforms;\n this.dependencies = dependencies;\n this.deprecations = this._parseDeprecationDefinitions(deprecations);\n this.defines = defines;\n this.injections = normalizeInjections(inject);\n\n if (uniforms) {\n this.uniforms = parsePropTypes(uniforms);\n }\n }\n\n // Extracts the source code chunk for the specified shader type from the named shader module\n getModuleSource(type) {\n let moduleSource;\n switch (type) {\n case VERTEX_SHADER:\n moduleSource = this.vs \|\| '';\n break;\n case FRAGMENT_SHADER:\n moduleSource = this.fs \|\| '';\n break;\n default:\n assert(false);\n }\n\n return `\\\n#define MODULE_${this.name.toUpperCase().replace(/[^0-9a-z]/gi, '_')}\n${moduleSource}\\\n// END MODULE_${this.name}\n\n`;\n }\n\n getUniforms(opts, uniforms) {\n if (this.getModuleUniforms) {\n return this.getModuleUniforms(opts, uniforms);\n }\n // Build uniforms from the uniforms array\n if (this.uniforms) {\n return this._defaultGetUniforms(opts);\n }\n return {};\n }\n\n getDefines() {\n return this.defines;\n }\n\n // Warn about deprecated uniforms or functions\n checkDeprecations(shaderSource, log) {\n this.deprecations.forEach(def => {\n if (def.regex.test(shaderSource)) {\n if (def.deprecated) {\n log.deprecated(def.old, def.new)();\n } else {\n log.removed(def.old, def.new)();\n }\n }\n });\n }\n\n _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\n return deprecations;\n }\n\n _defaultGetUniforms(opts = {}) {\n const uniforms = {};\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// This utility mutates the original module\n// Keeping for backward compatibility\n// TODO - remove in v8\nexport function normalizeShaderModule(module) {\n if (!module.normalized) {\n module.normalized = true;\n if (module.uniforms && !module.getUniforms) {\n const shaderModule = new ShaderModule(module);\n module.getUniforms = shaderModule.getUniforms.bind(shaderModule);\n }\n }\n return module;\n}\n\nfunction normalizeInjections(injections) {\n const result = {\n vs: {},\n fs: {}\n };\n\n for (const hook in injections) {\n let injection = injections[hook];\n const stage = hook.slice(0, 2);\n\n if (typeof injection === 'string') {\n injection = {\n order: 0,\n injection\n };\n }\n\n result[stage][hook] = injection;\n }\n\n return result;\n}\n"],"~~file~~":"~~shader-module.js~~"}
1	+ {"version":3,"file":"shader-module.js","names":["VERTEX_SHADER","FRAGMENT_SHADER","ShaderModule","name","vs","fs","dependencies","uniforms","getUniforms","deprecations","defines","inject","vertexShader","fragmentShader","assert","getModuleUniforms","_parseDeprecationDefinitions","injections","normalizeInjections","parsePropTypes","type","moduleSource","toUpperCase","replace","opts","_defaultGetUniforms","shaderSource","log","forEach","def","regex","test","deprecated","old","new","removed","RegExp","propTypes","key","propDef","private","validate","value","normalizeShaderModule","module","normalized","shaderModule","bind","result","hook","injection","stage","slice","order"],"sources":["../../../src/lib/shader-module.js"],"sourcesContent":["import {assert} from '../utils';\nimport {parsePropTypes} from './filters/prop-types';\n\nconst VERTEX_SHADER = 'vs';\nconst FRAGMENT_SHADER = 'fs';\n\nexport default class ShaderModule {\n constructor({\n name,\n vs,\n fs,\n dependencies = [],\n uniforms,\n getUniforms,\n deprecations = [],\n defines = {},\n inject = {},\n // DEPRECATED\n vertexShader,\n fragmentShader\n }) {\n assert(typeof name === 'string');\n this.name = name;\n this.vs = vs \|\| vertexShader;\n this.fs = fs \|\| fragmentShader;\n this.getModuleUniforms = getUniforms;\n this.dependencies = dependencies;\n this.deprecations = this._parseDeprecationDefinitions(deprecations);\n this.defines = defines;\n this.injections = normalizeInjections(inject);\n\n if (uniforms) {\n this.uniforms = parsePropTypes(uniforms);\n }\n }\n\n // Extracts the source code chunk for the specified shader type from the named shader module\n getModuleSource(type) {\n let moduleSource;\n switch (type) {\n case VERTEX_SHADER:\n moduleSource = this.vs \|\| '';\n break;\n case FRAGMENT_SHADER:\n moduleSource = this.fs \|\| '';\n break;\n default:\n assert(false);\n }\n\n return `\\\n#define MODULE_${this.name.toUpperCase().replace(/[^0-9a-z]/gi, '_')}\n${moduleSource}\\\n// END MODULE_${this.name}\n\n`;\n }\n\n getUniforms(opts, uniforms) {\n if (this.getModuleUniforms) {\n return this.getModuleUniforms(opts, uniforms);\n }\n // Build uniforms from the uniforms array\n if (this.uniforms) {\n return this._defaultGetUniforms(opts);\n }\n return {};\n }\n\n getDefines() {\n return this.defines;\n }\n\n // Warn about deprecated uniforms or functions\n checkDeprecations(shaderSource, log) {\n this.deprecations.forEach(def => {\n if (def.regex.test(shaderSource)) {\n if (def.deprecated) {\n log.deprecated(def.old, def.new)();\n } else {\n log.removed(def.old, def.new)();\n }\n }\n });\n }\n\n _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\n return deprecations;\n }\n\n _defaultGetUniforms(opts = {}) {\n const uniforms = {};\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// This utility mutates the original module\n// Keeping for backward compatibility\n// TODO - remove in v8\nexport function normalizeShaderModule(module) {\n if (!module.normalized) {\n module.normalized = true;\n if (module.uniforms && !module.getUniforms) {\n const shaderModule = new ShaderModule(module);\n module.getUniforms = shaderModule.getUniforms.bind(shaderModule);\n }\n }\n return module;\n}\n\nfunction normalizeInjections(injections) {\n const result = {\n vs: {},\n fs: {}\n };\n\n for (const hook in injections) {\n let injection = injections[hook];\n const stage = hook.slice(0, 2);\n\n if (typeof injection === 'string') {\n injection = {\n order: 0,\n injection\n };\n }\n\n result[stage][hook] = injection;\n }\n\n return result;\n}\n"],"mappings":";;;;;;;;;;;;;;AAAA;;AACA;;AAEA,IAAMA,aAAa,GAAG,IAAtB;AACA,IAAMC,eAAe,GAAG,IAAxB;;IAEqBC,Y;EACnB,4BAaG;IAAA,IAZDC,IAYC,QAZDA,IAYC;IAAA,IAXDC,EAWC,QAXDA,EAWC;IAAA,IAVDC,EAUC,QAVDA,EAUC;IAAA,6BATDC,YASC;IAAA,IATDA,YASC,kCATc,EASd;IAAA,IARDC,QAQC,QARDA,QAQC;IAAA,IAPDC,WAOC,QAPDA,WAOC;IAAA,6BANDC,YAMC;IAAA,IANDA,YAMC,kCANc,EAMd;IAAA,wBALDC,OAKC;IAAA,IALDA,OAKC,6BALS,EAKT;IAAA,uBAJDC,MAIC;IAAA,IAJDA,MAIC,4BAJQ,EAIR;IAAA,IAFDC,YAEC,QAFDA,YAEC;IAAA,IADDC,cACC,QADDA,cACC;IAAA;IACD,IAAAC,aAAA,EAAO,OAAOX,IAAP,KAAgB,QAAvB;IACA,KAAKA,IAAL,GAAYA,IAAZ;IACA,KAAKC,EAAL,GAAUA,EAAE,IAAIQ,YAAhB;IACA,KAAKP,EAAL,GAAUA,EAAE,IAAIQ,cAAhB;IACA,KAAKE,iBAAL,GAAyBP,WAAzB;IACA,KAAKF,YAAL,GAAoBA,YAApB;IACA,KAAKG,YAAL,GAAoB,KAAKO,4BAAL,CAAkCP,YAAlC,CAApB;IACA,KAAKC,OAAL,GAAeA,OAAf;IACA,KAAKO,UAAL,GAAkBC,mBAAmB,CAACP,MAAD,CAArC;;IAEA,IAAIJ,QAAJ,EAAc;MACZ,KAAKA,QAAL,GAAgB,IAAAY,yBAAA,EAAeZ,QAAf,CAAhB;IACD;EACF;;;;WAGD,yBAAgBa,IAAhB,EAAsB;MACpB,IAAIC,YAAJ;;MACA,QAAQD,IAAR;QACE,KAAKpB,aAAL;UACEqB,YAAY,GAAG,KAAKjB,EAAL,IAAW,EAA1B;UACA;;QACF,KAAKH,eAAL;UACEoB,YAAY,GAAG,KAAKhB,EAAL,IAAW,EAA1B;UACA;;QACF;UACE,IAAAS,aAAA,EAAO,KAAP;MARJ;;MAWA,gCACa,KAAKX,IAAL,CAAUmB,WAAV,GAAwBC,OAAxB,CAAgC,aAAhC,EAA+C,GAA/C,CADb,eAEFF,YAFE,2BAGY,KAAKlB,IAHjB;IAMD;;;WAED,qBAAYqB,IAAZ,EAAkBjB,QAAlB,EAA4B;MAC1B,IAAI,KAAKQ,iBAAT,EAA4B;QAC1B,OAAO,KAAKA,iBAAL,CAAuBS,IAAvB,EAA6BjB,QAA7B,CAAP;MACD;;MAED,IAAI,KAAKA,QAAT,EAAmB;QACjB,OAAO,KAAKkB,mBAAL,CAAyBD,IAAzB,CAAP;MACD;;MACD,OAAO,EAAP;IACD;;;WAED,sBAAa;MACX,OAAO,KAAKd,OAAZ;IACD;;;WAGD,2BAAkBgB,YAAlB,EAAgCC,GAAhC,EAAqC;MACnC,KAAKlB,YAAL,CAAkBmB,OAAlB,CAA0B,UAAAC,GAAG,EAAI;QAC/B,IAAIA,GAAG,CAACC,KAAJ,CAAUC,IAAV,CAAeL,YAAf,CAAJ,EAAkC;UAChC,IAAIG,GAAG,CAACG,UAAR,EAAoB;YAClBL,GAAG,CAACK,UAAJ,CAAeH,GAAG,CAACI,GAAnB,EAAwBJ,GAAG,CAACK,GAA5B;UACD,CAFD,MAEO;YACLP,GAAG,CAACQ,OAAJ,CAAYN,GAAG,CAACI,GAAhB,EAAqBJ,GAAG,CAACK,GAAzB;UACD;QACF;MACF,CARD;IASD;;;WAED,sCAA6BzB,YAA7B,EAA2C;MACzCA,YAAY,CAACmB,OAAb,CAAqB,UAAAC,GAAG,EAAI;QAC1B,QAAQA,GAAG,CAACT,IAAZ;UACE,KAAK,UAAL;YACES,GAAG,CAACC,KAAJ,GAAY,IAAIM,MAAJ,cAAiBP,GAAG,CAACI,GAArB,SAAZ;YACA;;UACF;YACEJ,GAAG,CAACC,KAAJ,GAAY,IAAIM,MAAJ,WAAcP,GAAG,CAACT,IAAlB,cAA0BS,GAAG,CAACI,GAA9B,OAAZ;QALJ;MAOD,CARD;MAUA,OAAOxB,YAAP;IACD;;;WAED,+BAA+B;MAAA,IAAXe,IAAW,uEAAJ,EAAI;MAC7B,IAAMjB,QAAQ,GAAG,EAAjB;MACA,IAAM8B,SAAS,GAAG,KAAK9B,QAAvB;;MAEA,KAAK,IAAM+B,GAAX,IAAkBD,SAAlB,EAA6B;QAC3B,IAAME,OAAO,GAAGF,SAAS,CAACC,GAAD,CAAzB;;QACA,IAAIA,GAAG,IAAId,IAAP,IAAe,CAACe,OAAO,CAACC,OAA5B,EAAqC;UACnC,IAAID,OAAO,CAACE,QAAZ,EAAsB;YACpB,IAAA3B,aAAA,EAAOyB,OAAO,CAACE,QAAR,CAAiBjB,IAAI,CAACc,GAAD,CAArB,EAA4BC,OAA5B,CAAP,YAAgD,KAAKpC,IAArD,uBAAsEmC,GAAtE;UACD;;UACD/B,QAAQ,CAAC+B,GAAD,CAAR,GAAgBd,IAAI,CAACc,GAAD,CAApB;QACD,CALD,MAKO;UACL/B,QAAQ,CAAC+B,GAAD,CAAR,GAAgBC,OAAO,CAACG,KAAxB;QACD;MACF;;MAED,OAAOnC,QAAP;IACD;;;;;;;AAMI,SAASoC,qBAAT,CAA+BC,MAA/B,EAAuC;EAC5C,IAAI,CAACA,MAAM,CAACC,UAAZ,EAAwB;IACtBD,MAAM,CAACC,UAAP,GAAoB,IAApB;;IACA,IAAID,MAAM,CAACrC,QAAP,IAAmB,CAACqC,MAAM,CAACpC,WAA/B,EAA4C;MAC1C,IAAMsC,YAAY,GAAG,IAAI5C,YAAJ,CAAiB0C,MAAjB,CAArB;MACAA,MAAM,CAACpC,WAAP,GAAqBsC,YAAY,CAACtC,WAAb,CAAyBuC,IAAzB,CAA8BD,YAA9B,CAArB;IACD;EACF;;EACD,OAAOF,MAAP;AACD;;AAED,SAAS1B,mBAAT,CAA6BD,UAA7B,EAAyC;EACvC,IAAM+B,MAAM,GAAG;IACb5C,EAAE,EAAE,EADS;IAEbC,EAAE,EAAE;EAFS,CAAf;;EAKA,KAAK,IAAM4C,IAAX,IAAmBhC,UAAnB,EAA+B;IAC7B,IAAIiC,SAAS,GAAGjC,UAAU,CAACgC,IAAD,CAA1B;IACA,IAAME,KAAK,GAAGF,IAAI,CAACG,KAAL,CAAW,CAAX,EAAc,CAAd,CAAd;;IAEA,IAAI,OAAOF,SAAP,KAAqB,QAAzB,EAAmC;MACjCA,SAAS,GAAG;QACVG,KAAK,EAAE,CADG;QAEVH,SAAS,EAATA;MAFU,CAAZ;IAID;;IAEDF,MAAM,CAACG,KAAD,CAAN,CAAcF,IAAd,IAAsBC,SAAtB;EACD;;EAED,OAAOF,MAAP;AACD"}

package/dist/es5/lib/transpile-shader.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"~~sources~~":["~~../../../src/lib/~~transpile-shader.js"],"names":["testVariable","qualifier","RegExp","ES300_REPLACEMENTS","ES300_VERTEX_REPLACEMENTS","ES300_FRAGMENT_REPLACEMENTS","ES100_REPLACEMENTS","ES100_VERTEX_REPLACEMENTS","ES100_FRAGMENT_REPLACEMENTS","ES100_FRAGMENT_OUTPUT_NAME","ES300_FRAGMENT_OUTPUT_REGEX","REGEX_START_OF_MAIN","transpileShader","source","targetGLSLVersion","isVertex","convertShader","convertFragmentShaderTo300","convertFragmentShaderTo100","Error","replacements","pattern","replacement","replace","outputMatch","match","outputName"],"~~mappings~~":"~~;;;;;;;;;;;;;;;;;AAEA,SAASA,YAAT,CAAsBC,SAAtB,EAAiC;AAQ~~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","sourcesContent":["// TRANSPILATION TABLES\n\nfunction testVariable(qualifier) {\n /\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 /\n return new RegExp(`\\\\b${qualifier}[ \\\\t]+(\\\\w+[ \\\\t]+\\\\w+(\\\\[\\\\w+\\\\])?;)`, 'g');\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];\n\nconst ES300_VERTEX_REPLACEMENTS = [\n ...ES300_REPLACEMENTS,\n // `attribute` keyword replaced with `in`\n [testVariable('attribute'), 'in $1'],\n // `varying` keyword replaced with `out`\n [testVariable('varying'), 'out $1']\n];\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 [testVariable('varying'), 'in $1']\n];\n\nconst ES100_REPLACEMENTS = [\n [/^#version[ \\t]+300[ \\t]+es/, '#version 100'],\n\n // In GLSL 1.00 ES these functions are provided by an extension\n [/\\btexture(2D\|2DProj\|Cube)Lod\$/g, 'texture$1LodEXT('],\n\n // Overloads in GLSL 3.00 map to individual functions. Note that we cannot\n // differentiate 2D,2DProj,Cube without type analysis so we choose the most common variant.\n [/\\btexture\\(/g, 'texture2D('],\n [/\\btextureLod\\(/g, 'texture2DLodEXT(']\n];\n\nconst ES100_VERTEX_REPLACEMENTS = [\n ...ES100_REPLACEMENTS,\n [testVariable('in'), 'attribute $1'],\n [testVariable('out'), 'varying $1']\n];\n\nconst ES100_FRAGMENT_REPLACEMENTS = [\n ...ES100_REPLACEMENTS,\n // Replace `in` with `varying`\n [testVariable('in'), 'varying $1']\n];\n\nconst ES100_FRAGMENT_OUTPUT_NAME = 'gl_FragColor';\nconst ES300_FRAGMENT_OUTPUT_REGEX = /\\bout[ \\t]+vec4[ \\t]+(\\w+)[ \\t];\\n?/;\n\nconst REGEX_START_OF_MAIN = /void\\s+main\\s\\([^)]\$\\s*\\{\\n?/; // Beginning of main\n\n// Transpiles shader source code to target GLSL version\n// Note: We always run transpiler even if same version e.g. 3.00 => 3.00\n// RFC: https://github.com/visgl/luma.gl/blob/7.0-release/dev-docs/RFCs/v6.0/portable-glsl-300-rfc.md\nexport default function transpileShader(source, targetGLSLVersion, isVertex) {\n switch (targetGLSLVersion) {\n case 300:\n return isVertex\n ? convertShader(source, ES300_VERTEX_REPLACEMENTS)\n : convertFragmentShaderTo300(source);\n case 100:\n return isVertex\n ? convertShader(source, ES100_VERTEX_REPLACEMENTS)\n : convertFragmentShaderTo100(source);\n default:\n throw new Error(`unknown GLSL version ${targetGLSLVersion}`);\n }\n}\n\nfunction convertShader(source, replacements) {\n for (const [pattern, replacement] of replacements) {\n source = source.replace(pattern, replacement);\n }\n return source;\n}\n\nfunction convertFragmentShaderTo300(source) {\n source = convertShader(source, ES300_FRAGMENT_REPLACEMENTS);\n\n const outputMatch = source.match(ES300_FRAGMENT_OUTPUT_REGEX);\n if (outputMatch) {\n const outputName = outputMatch[1];\n source = source.replace(new RegExp(`\\\\b${ES100_FRAGMENT_OUTPUT_NAME}\\\\b`, 'g'), outputName);\n } else {\n const outputName = 'fragmentColor';\n source = source\n .replace(REGEX_START_OF_MAIN, match => `out vec4 ${outputName};\\n${match}`)\n .replace(new RegExp(`\\\\b${ES100_FRAGMENT_OUTPUT_NAME}\\\\b`, 'g'), outputName);\n }\n\n return source;\n}\n\nfunction convertFragmentShaderTo100(source) {\n source = convertShader(source, ES100_FRAGMENT_REPLACEMENTS);\n\n const outputMatch = source.match(ES300_FRAGMENT_OUTPUT_REGEX);\n if (outputMatch) {\n const outputName = outputMatch[1];\n source = source\n .replace(ES300_FRAGMENT_OUTPUT_REGEX, '')\n .replace(new RegExp(`\\\\b${outputName}\\\\b`, 'g'), ES100_FRAGMENT_OUTPUT_NAME);\n }\n\n return source;\n}\n"],"~~file~~":"~~transpile-shader.js~~"}
1	+ {"version":3,"file":"transpile-shader.js","names":["testVariable","qualifier","RegExp","ES300_REPLACEMENTS","ES300_VERTEX_REPLACEMENTS","ES300_FRAGMENT_REPLACEMENTS","ES100_REPLACEMENTS","ES100_VERTEX_REPLACEMENTS","ES100_FRAGMENT_REPLACEMENTS","ES100_FRAGMENT_OUTPUT_NAME","ES300_FRAGMENT_OUTPUT_REGEX","REGEX_START_OF_MAIN","transpileShader","source","targetGLSLVersion","isVertex","convertShader","convertFragmentShaderTo300","convertFragmentShaderTo100","Error","replacements","pattern","replacement","replace","outputMatch","match","outputName"],"sources":["../../../src/lib/transpile-shader.js"],"sourcesContent":["// TRANSPILATION TABLES\n\nfunction testVariable(qualifier) {\n /\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 /\n return new RegExp(`\\\\b${qualifier}[ \\\\t]+(\\\\w+[ \\\\t]+\\\\w+(\\\\[\\\\w+\\\\])?;)`, 'g');\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];\n\nconst ES300_VERTEX_REPLACEMENTS = [\n ...ES300_REPLACEMENTS,\n // `attribute` keyword replaced with `in`\n [testVariable('attribute'), 'in $1'],\n // `varying` keyword replaced with `out`\n [testVariable('varying'), 'out $1']\n];\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 [testVariable('varying'), 'in $1']\n];\n\nconst ES100_REPLACEMENTS = [\n [/^#version[ \\t]+300[ \\t]+es/, '#version 100'],\n\n // In GLSL 1.00 ES these functions are provided by an extension\n [/\\btexture(2D\|2DProj\|Cube)Lod\$/g, 'texture$1LodEXT('],\n\n // Overloads in GLSL 3.00 map to individual functions. Note that we cannot\n // differentiate 2D,2DProj,Cube without type analysis so we choose the most common variant.\n [/\\btexture\\(/g, 'texture2D('],\n [/\\btextureLod\\(/g, 'texture2DLodEXT(']\n];\n\nconst ES100_VERTEX_REPLACEMENTS = [\n ...ES100_REPLACEMENTS,\n [testVariable('in'), 'attribute $1'],\n [testVariable('out'), 'varying $1']\n];\n\nconst ES100_FRAGMENT_REPLACEMENTS = [\n ...ES100_REPLACEMENTS,\n // Replace `in` with `varying`\n [testVariable('in'), 'varying $1']\n];\n\nconst ES100_FRAGMENT_OUTPUT_NAME = 'gl_FragColor';\nconst ES300_FRAGMENT_OUTPUT_REGEX = /\\bout[ \\t]+vec4[ \\t]+(\\w+)[ \\t];\\n?/;\n\nconst REGEX_START_OF_MAIN = /void\\s+main\\s\\([^)]\$\\s*\\{\\n?/; // Beginning of main\n\n// Transpiles shader source code to target GLSL version\n// Note: We always run transpiler even if same version e.g. 3.00 => 3.00\n// RFC: https://github.com/visgl/luma.gl/blob/7.0-release/dev-docs/RFCs/v6.0/portable-glsl-300-rfc.md\nexport default function transpileShader(source, targetGLSLVersion, isVertex) {\n switch (targetGLSLVersion) {\n case 300:\n return isVertex\n ? convertShader(source, ES300_VERTEX_REPLACEMENTS)\n : convertFragmentShaderTo300(source);\n case 100:\n return isVertex\n ? convertShader(source, ES100_VERTEX_REPLACEMENTS)\n : convertFragmentShaderTo100(source);\n default:\n throw new Error(`unknown GLSL version ${targetGLSLVersion}`);\n }\n}\n\nfunction convertShader(source, replacements) {\n for (const [pattern, replacement] of replacements) {\n source = source.replace(pattern, replacement);\n }\n return source;\n}\n\nfunction convertFragmentShaderTo300(source) {\n source = convertShader(source, ES300_FRAGMENT_REPLACEMENTS);\n\n const outputMatch = source.match(ES300_FRAGMENT_OUTPUT_REGEX);\n if (outputMatch) {\n const outputName = outputMatch[1];\n source = source.replace(new RegExp(`\\\\b${ES100_FRAGMENT_OUTPUT_NAME}\\\\b`, 'g'), outputName);\n } else {\n const outputName = 'fragmentColor';\n source = source\n .replace(REGEX_START_OF_MAIN, match => `out vec4 ${outputName};\\n${match}`)\n .replace(new RegExp(`\\\\b${ES100_FRAGMENT_OUTPUT_NAME}\\\\b`, 'g'), outputName);\n }\n\n return source;\n}\n\nfunction convertFragmentShaderTo100(source) {\n source = convertShader(source, ES100_FRAGMENT_REPLACEMENTS);\n\n const outputMatch = source.match(ES300_FRAGMENT_OUTPUT_REGEX);\n if (outputMatch) {\n const outputName = outputMatch[1];\n source = source\n .replace(ES300_FRAGMENT_OUTPUT_REGEX, '')\n .replace(new RegExp(`\\\\b${outputName}\\\\b`, 'g'), ES100_FRAGMENT_OUTPUT_NAME);\n }\n\n return source;\n}\n"],"mappings":"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"}

package/dist/es5/modules/dirlight/dirlight.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"~~sources~~":["~~../../../../src/modules/~~dirlight~~/dirlight~~.js"],"names":["DEFAULT_LIGHT_DIRECTION","Float32Array","DEFAULT_MODULE_OPTIONS","lightDirection","getUniforms","opts","uniforms","dirlight_uLightDirection","vs","fs","dirlight","name","dependencies","project"],"~~mappings~~":"~~;;;;;;;AAIA;;AAGA,IAAMA,uBAAuB,GAAG,IAAIC,YAAJ,CAAiB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAjB,CAAhC;AAEA,IAAMC,sBAAsB,GAAG;AAC7BC,EAAAA,cAAc,EAAEH;AADa,CAA~~/~~B;;AAIA,SAASI,WAAT,GAAoD;AAAA,MAA~~/BC,IAA+B,uEAAxBH,sBAAwB;AAClD,MAAMI,QAAQ,GAAG,EAAjB;;AACA,MAAID,IAAI,CAACF,cAAT,EAAyB;AACvBG,IAAAA,QAAQ,CAACC,wBAAT,GAAoCF,IAAI,CAACF,cAAzC;AACD;;AACD,SAAOG,QAAP;AACD;;AAGD,IAAME,EAAE,GAAG,IAAX;AAEA,IAAMC,EAAE,4PAAR;AAaO,IAAMC,QAAQ,GAAG;AACtBC,EAAAA,IAAI,EAAE,UADgB;AAEtBH,EAAAA,EAAE,EAAFA,EAFsB;AAGtBC,EAAAA,EAAE,EAAFA,EAHsB;AAItBL,EAAAA,WAAW,EAAXA,WAJsB;AAKtBQ,EAAAA,YAAY,EAAE,CAACC,gBAAD;AALQ,CAAjB","sourcesContent":["/** @typedef {import('../../types').ShaderModule} ShaderModule /\n\n// Cheap lighting - single directional light, single dot product, one uniform\n\nimport {project} from '../project/project';\n\n/ eslint-disable camelcase /\nconst DEFAULT_LIGHT_DIRECTION = new Float32Array([1, 1, 2]);\n\nconst DEFAULT_MODULE_OPTIONS = {\n lightDirection: DEFAULT_LIGHT_DIRECTION\n};\n\nfunction getUniforms(opts = DEFAULT_MODULE_OPTIONS) {\n const uniforms = {};\n if (opts.lightDirection) {\n uniforms.dirlight_uLightDirection = opts.lightDirection;\n }\n return uniforms;\n}\n\n// TODO - reuse normal from geometry module\nconst vs = null;\n\nconst fs = `\\\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\nexport const dirlight = {\n name: 'dirlight',\n vs,\n fs,\n getUniforms,\n dependencies: [project]\n};\n"],"~~file~~":"~~dirlight.js~~"}
1	+ {"version":3,"file":"dirlight.js","names":["DEFAULT_LIGHT_DIRECTION","Float32Array","DEFAULT_MODULE_OPTIONS","lightDirection","getUniforms","opts","uniforms","dirlight_uLightDirection","vs","fs","dirlight","name","dependencies","project"],"sources":["../../../../src/modules/dirlight/dirlight.js"],"sourcesContent":["/** @typedef {import('../../types').ShaderModule} ShaderModule /\n\n// Cheap lighting - single directional light, single dot product, one uniform\n\nimport {project} from '../project/project';\n\n/ eslint-disable camelcase /\nconst DEFAULT_LIGHT_DIRECTION = new Float32Array([1, 1, 2]);\n\nconst DEFAULT_MODULE_OPTIONS = {\n lightDirection: DEFAULT_LIGHT_DIRECTION\n};\n\nfunction getUniforms(opts = DEFAULT_MODULE_OPTIONS) {\n const uniforms = {};\n if (opts.lightDirection) {\n uniforms.dirlight_uLightDirection = opts.lightDirection;\n }\n return uniforms;\n}\n\n// TODO - reuse normal from geometry module\nconst vs = null;\n\nconst fs = `\\\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\nexport const dirlight = {\n name: 'dirlight',\n vs,\n fs,\n getUniforms,\n dependencies: [project]\n};\n"],"mappings":";;;;;;;AAIA;;AAGA,IAAMA,uBAAuB,GAAG,IAAIC,YAAJ,CAAiB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAjB,CAAhC;AAEA,IAAMC,sBAAsB,GAAG;EAC7BC,cAAc,EAAEH;AADa,CAA/B;;AAIA,SAASI,WAAT,GAAoD;EAAA,IAA/BC,IAA+B,uEAAxBH,sBAAwB;EAClD,IAAMI,QAAQ,GAAG,EAAjB;;EACA,IAAID,IAAI,CAACF,cAAT,EAAyB;IACvBG,QAAQ,CAACC,wBAAT,GAAoCF,IAAI,CAACF,cAAzC;EACD;;EACD,OAAOG,QAAP;AACD;;AAGD,IAAME,EAAE,GAAG,IAAX;AAEA,IAAMC,EAAE,4PAAR;AAaO,IAAMC,QAAQ,GAAG;EACtBC,IAAI,EAAE,UADgB;EAEtBH,EAAE,EAAFA,EAFsB;EAGtBC,EAAE,EAAFA,EAHsB;EAItBL,WAAW,EAAXA,WAJsB;EAKtBQ,YAAY,EAAE,CAACC,gBAAD;AALQ,CAAjB"}

package/dist/es5/modules/fp32/fp32.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"~~sources~~":["~~../../../../src/modules/~~fp32~~/fp32~~.js"],"names":["fp32shader","fp32","name","vs","fs"],"~~mappings~~":"~~;;;;;;AAEA,IAAMA,UAAU,qrGAAhB;AAyJO,IAAMC,IAAI,GAAG;AAClBC,EAAAA,IAAI,EAAE,MADY;AAElBC,EAAAA,EAAE,EAAEH,UAFc;AAGlBI,EAAAA,EAAE,EAAE;AAHc,CAAb~~","sourcesContent":["/** @typedef {import('../../types').ShaderModule} ShaderModule /\n\nconst fp32shader = `\\\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\nexport const fp32 = {\n name: 'fp32',\n vs: fp32shader,\n fs: null\n};\n"],"~~file~~":"~~fp32.js~~"}
1	+ {"version":3,"file":"fp32.js","names":["fp32shader","fp32","name","vs","fs"],"sources":["../../../../src/modules/fp32/fp32.js"],"sourcesContent":["/** @typedef {import('../../types').ShaderModule} ShaderModule /\n\nconst fp32shader = `\\\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\nexport const fp32 = {\n name: 'fp32',\n vs: fp32shader,\n fs: null\n};\n"],"mappings":";;;;;;AAEA,IAAMA,UAAU,qrGAAhB;AAyJO,IAAMC,IAAI,GAAG;EAClBC,IAAI,EAAE,MADY;EAElBC,EAAE,EAAEH,UAFc;EAGlBI,EAAE,EAAE;AAHc,CAAb"}

package/dist/es5/modules/fp64/fp64-arithmetic.glsl.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"~~sources~~":[],"names":[],"~~mappings~~":"","sourcesContent":[],"~~file~~":"~~fp64-~~arithmetic.~~glsl~~.js"}
1	+ {"version":3,"file":"fp64-arithmetic.glsl.js","names":[],"sources":["../../../../src/modules/fp64/fp64-arithmetic.glsl.js"],"sourcesContent":["// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nexport default `\\\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' from.\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"],"mappings":""}

package/dist/es5/modules/fp64/fp64-functions.glsl.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"fp64-functions.glsl.js"}
1	+ {"version":3,"file":"fp64-functions.glsl.js","names":[],"sources":["../../../../src/modules/fp64/fp64-functions.glsl.js"],"sourcesContent":["// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nexport default `\\\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"],"mappings":""}

package/dist/es5/modules/fp64/fp64-utils.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"~~sources~~":["~~../../../../src/modules/~~fp64~~/fp64~~-utils.js"],"names":["fp64ify","a","out","startIndex","hiPart","Math","fround","loPart","fp64LowPart","fp64ifyMatrix4","matrix","matrixFP64","Float32Array","i","j","index"],"~~mappings~~":";;;;;;;;;AAMO,SAASA,OAAT,CAAiBC,CAAjB,EAA8C;AAAA,MAA1BC,GAA0B,uEAApB,EAAoB;AAAA,MAAhBC,UAAgB,uEAAH,CAAG;AACnD,MAAMC,MAAM,GAAGC,IAAI,CAACC,MAAL,CAAYL,CAAZ,CAAf;AACA,MAAMM,MAAM,GAAGN,CAAC,GAAGG,MAAnB;AACAF,EAAAA,GAAG,CAACC,UAAD,CAAH,GAAkBC,MAAlB;AACAF,EAAAA,GAAG,CAACC,UAAU,GAAG,CAAd,CAAH,GAAsBI,MAAtB;AACA,SAAOL,GAAP;AACD;;AAGM,SAASM,WAAT,CAAqBP,CAArB,EAAwB;AAC7B,SAAOA,CAAC,GAAGI,IAAI,CAACC,MAAL,CAAYL,CAAZ,CAAX;AACD;;AAMM,SAASQ,cAAT,CAAwBC,MAAxB,EAAgC;AAErC,MAAMC,UAAU,GAAG,IAAIC,YAAJ,CAAiB,EAAjB,CAAnB;;AACA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,CAApB,EAAuB,EAAEA,CAAzB,EAA4B;AAC1B,SAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,CAApB,EAAuB,EAAEA,CAAzB,EAA4B;AAC1B,UAAMC,KAAK,GAAGF,CAAC,GAAG,CAAJ,GAAQC,CAAtB;AACAd,MAAAA,OAAO,CAACU,MAAM,CAACI,CAAC,GAAG,CAAJ,GAAQD,CAAT,CAAP,EAAoBF,UAApB,EAAgCI,KAAK,GAAG,CAAxC,CAAP;AACD;AACF;;AACD,SAAOJ,UAAP;AACD","sourcesContent":["/** @typedef {import('./fp64-utils')} types /\n\n/\n Calculate WebGL 64 bit float\n * @type {types['fp64ify']}\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/* @type {types['fp64LowPart']} /\nexport function fp64LowPart(a) {\n return a - Math.fround(a);\n}\n\n/\n Calculate WebGL 64 bit matrix (transposed \"Float64Array\")\n * @type {types['fp64ifyMatrix4']}\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"],"~~file~~":"~~fp64-utils.js~~"}
1	+ {"version":3,"file":"fp64-utils.js","names":["fp64ify","a","out","startIndex","hiPart","Math","fround","loPart","fp64LowPart","fp64ifyMatrix4","matrix","matrixFP64","Float32Array","i","j","index"],"sources":["../../../../src/modules/fp64/fp64-utils.js"],"sourcesContent":["/** @typedef {import('./fp64-utils')} types /\n\n/\n Calculate WebGL 64 bit float\n * @type {types['fp64ify']}\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/* @type {types['fp64LowPart']} /\nexport function fp64LowPart(a) {\n return a - Math.fround(a);\n}\n\n/\n Calculate WebGL 64 bit matrix (transposed \"Float64Array\")\n * @type {types['fp64ifyMatrix4']}\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"],"mappings":";;;;;;;;;AAMO,SAASA,OAAT,CAAiBC,CAAjB,EAA8C;EAAA,IAA1BC,GAA0B,uEAApB,EAAoB;EAAA,IAAhBC,UAAgB,uEAAH,CAAG;EACnD,IAAMC,MAAM,GAAGC,IAAI,CAACC,MAAL,CAAYL,CAAZ,CAAf;EACA,IAAMM,MAAM,GAAGN,CAAC,GAAGG,MAAnB;EACAF,GAAG,CAACC,UAAD,CAAH,GAAkBC,MAAlB;EACAF,GAAG,CAACC,UAAU,GAAG,CAAd,CAAH,GAAsBI,MAAtB;EACA,OAAOL,GAAP;AACD;;AAGM,SAASM,WAAT,CAAqBP,CAArB,EAAwB;EAC7B,OAAOA,CAAC,GAAGI,IAAI,CAACC,MAAL,CAAYL,CAAZ,CAAX;AACD;;AAMM,SAASQ,cAAT,CAAwBC,MAAxB,EAAgC;EAErC,IAAMC,UAAU,GAAG,IAAIC,YAAJ,CAAiB,EAAjB,CAAnB;;EACA,KAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,CAApB,EAAuB,EAAEA,CAAzB,EAA4B;IAC1B,KAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,CAApB,EAAuB,EAAEA,CAAzB,EAA4B;MAC1B,IAAMC,KAAK,GAAGF,CAAC,GAAG,CAAJ,GAAQC,CAAtB;MACAd,OAAO,CAACU,MAAM,CAACI,CAAC,GAAG,CAAJ,GAAQD,CAAT,CAAP,EAAoBF,UAApB,EAAgCI,KAAK,GAAG,CAAxC,CAAP;IACD;EACF;;EACD,OAAOJ,UAAP;AACD"}

package/dist/es5/modules/fp64/fp64.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"~~sources~~":["~~../../../../src/modules/~~fp64~~/fp64~~.js"],"names":["CONST_UNIFORMS","ONE","getUniforms","fp64arithmetic","name","vs","fp64arithmeticShader","fs","fp64ify","fp64LowPart","fp64ifyMatrix4","fp64","fp64functionShader","dependencies"],"~~mappings~~":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA;;AAEA;;AACA;;AAEA,IAAMA,cAAc,GAAG;AAErBC,EAAAA,GAAG,EAAE;AAFgB,CAAvB;;AAMA,SAASC,WAAT,GAAuB;AACrB,SAAOF,cAAP;AACD;;AAGM,IAAMG,cAAc,GAAG;AAC5BC,EAAAA,IAAI,EAAE,iBADsB;AAE5BC,EAAAA,EAAE,EAAEC,uBAFwB;AAG5BC,EAAAA,EAAE,EAAE,IAHwB;AAI5BL,EAAAA,WAAW,EAAXA,WAJ4B;AAK5BM,EAAAA,OAAO,EAAPA,kBAL4B;AAM5BC,EAAAA,WAAW,EAAXA,sBAN4B;AAO5BC,EAAAA,cAAc,EAAdA;AAP4B,CAAvB;;AAWA,IAAMC,IAAI,GAAG;AAClBP,EAAAA,IAAI,EAAE,MADY;AAElBC,EAAAA,EAAE,EAAEO,sBAFc;AAGlBL,EAAAA,EAAE,EAAE,IAHc;AAIlBM,EAAAA,YAAY,EAAE,CAACV,cAAD,CAJI;AAKlBK,EAAAA,OAAO,EAAPA,kBALkB;AAMlBC,EAAAA,WAAW,EAAXA,sBANkB;AAOlBC,EAAAA,cAAc,EAAdA;AAPkB,CAAb","sourcesContent":["/** @typedef {import('../../types').ShaderModule} ShaderModule */\n\nimport {fp64ify, fp64LowPart, fp64ifyMatrix4} from './fp64-utils';\n\nimport fp64arithmeticShader from './fp64-arithmetic.glsl';\nimport fp64functionShader from './fp64-functions.glsl';\n\nconst CONST_UNIFORMS = {\n // Used in LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n ONE: 1.0\n};\nexport {fp64ify, fp64LowPart, fp64ifyMatrix4};\n\nfunction getUniforms() {\n return CONST_UNIFORMS;\n}\n\n// Arithmetic only\nexport const fp64arithmetic = {\n name: 'fp64-arithmetic',\n vs: fp64arithmeticShader,\n fs: null,\n getUniforms,\n fp64ify,\n fp64LowPart,\n fp64ifyMatrix4\n};\n\n// Full fp64 shader\nexport const fp64 = {\n name: 'fp64',\n vs: fp64functionShader,\n fs: null,\n dependencies: [fp64arithmetic],\n fp64ify,\n fp64LowPart,\n fp64ifyMatrix4\n};\n"],"~~file~~":"~~fp64.js~~"}
1	+ {"version":3,"file":"fp64.js","names":["CONST_UNIFORMS","ONE","getUniforms","fp64arithmetic","name","vs","fp64arithmeticShader","fs","fp64ify","fp64LowPart","fp64ifyMatrix4","fp64","fp64functionShader","dependencies"],"sources":["../../../../src/modules/fp64/fp64.js"],"sourcesContent":["/** @typedef {import('../../types').ShaderModule} ShaderModule */\n\nimport {fp64ify, fp64LowPart, fp64ifyMatrix4} from './fp64-utils';\n\nimport fp64arithmeticShader from './fp64-arithmetic.glsl';\nimport fp64functionShader from './fp64-functions.glsl';\n\nconst CONST_UNIFORMS = {\n // Used in LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n ONE: 1.0\n};\nexport {fp64ify, fp64LowPart, fp64ifyMatrix4};\n\nfunction getUniforms() {\n return CONST_UNIFORMS;\n}\n\n// Arithmetic only\nexport const fp64arithmetic = {\n name: 'fp64-arithmetic',\n vs: fp64arithmeticShader,\n fs: null,\n getUniforms,\n fp64ify,\n fp64LowPart,\n fp64ifyMatrix4\n};\n\n// Full fp64 shader\nexport const fp64 = {\n name: 'fp64',\n vs: fp64functionShader,\n fs: null,\n dependencies: [fp64arithmetic],\n fp64ify,\n fp64LowPart,\n fp64ifyMatrix4\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA;;AAEA;;AACA;;AAEA,IAAMA,cAAc,GAAG;EAErBC,GAAG,EAAE;AAFgB,CAAvB;;AAMA,SAASC,WAAT,GAAuB;EACrB,OAAOF,cAAP;AACD;;AAGM,IAAMG,cAAc,GAAG;EAC5BC,IAAI,EAAE,iBADsB;EAE5BC,EAAE,EAAEC,uBAFwB;EAG5BC,EAAE,EAAE,IAHwB;EAI5BL,WAAW,EAAXA,WAJ4B;EAK5BM,OAAO,EAAPA,kBAL4B;EAM5BC,WAAW,EAAXA,sBAN4B;EAO5BC,cAAc,EAAdA;AAP4B,CAAvB;;AAWA,IAAMC,IAAI,GAAG;EAClBP,IAAI,EAAE,MADY;EAElBC,EAAE,EAAEO,sBAFc;EAGlBL,EAAE,EAAE,IAHc;EAIlBM,YAAY,EAAE,CAACV,cAAD,CAJI;EAKlBK,OAAO,EAAPA,kBALkB;EAMlBC,WAAW,EAAXA,sBANkB;EAOlBC,cAAc,EAAdA;AAPkB,CAAb"}