@luma.gl/shadertools 9.0.0-alpha.12 → 9.0.0-alpha.14

package/dist/index.d.ts

@@ -7,6 +7,11 @@ export type { CompilerMessage } from './lib/compiler-log/compiler-message';
 export { formatCompilerLog } from './lib/compiler-log/format-compiler-log';
 export { getShaderInfo } from './lib/glsl-utils/get-shader-info';
 export { getQualifierDetails, getPassthroughFS, typeToChannelSuffix, typeToChannelCount, convertToVec4 } from './lib/glsl-utils/shader-utils';
+/**
+ * Marks GLSL shaders for syntax highlighting: glsl`...`
+ * Install https://marketplace.visualstudio.com/items?itemName=boyswan.glsl-literal
+ */
+export { glsl } from './lib/glsl-utils/highlight';
 export { random } from './modules/utils/random';
 export { fp32 } from './modules/fp32/fp32';
 export { fp64, fp64arithmetic } from './modules/fp64/fp64';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,YAAY,EAAC,YAAY,EAAC,MAAM,mCAAmC,CAAC;AACpE,YAAY,EAAC,UAAU,EAAC,MAAM,iCAAiC,CAAC;AAEhE,OAAO,EAAC,eAAe,EAAC,MAAM,yCAAyC,CAAC;AAGxE,OAAO,EAAC,cAAc,EAAC,MAAM,sCAAsC,CAAC;AACpE,OAAO,EAAC,qBAAqB,EAAC,MAAM,6CAA6C,CAAC;AAGlF,YAAY,EAAC,eAAe,EAAC,MAAM,qCAAqC,CAAC;AACzE,OAAO,EAAC,iBAAiB,EAAC,MAAM,wCAAwC,CAAC;AAGzE,OAAO,EAAC,aAAa,EAAC,MAAM,kCAAkC,CAAC;AAC/D,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,EAClB,aAAa,EACd,MAAM,+BAA+B,CAAC;AAKvC,OAAO,EAAC,MAAM,EAAC,MAAM,wBAAwB,CAAC;AAG9C,OAAO,EAAC,IAAI,EAAC,MAAM,qBAAqB,CAAC;AACzC,OAAO,EAAC,IAAI,EAAE,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAGzD,OAAO,EAAC,OAAO,EAAC,MAAM,2BAA2B,CAAC;AAClD,OAAO,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAC/C,OAAO,EAAC,QAAQ,EAAC,MAAM,6BAA6B,CAAC;AACrD,OAAO,EAAC,OAAO,EAAC,MAAM,2BAA2B,CAAC;AAClD,OAAO,EAAC,eAAe,EAAE,aAAa,EAAC,MAAM,yCAAyC,CAAC;AACvF,OAAO,EAAC,GAAG,EAAC,MAAM,mBAAmB,CAAC;AAGtC,OAAO,EAAC,SAAS,EAAC,MAAM,wCAAwC,CAAC;AACjE,OAAO,EAAC,YAAY,EAAC,MAAM,2CAA2C,CAAC;AACvE,OAAO,EAAC,QAAQ,EAAC,MAAM,uCAAuC,CAAC;AAG/D,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,mDAAmD,CAAC;AAC/F,YAAY,EAAC,uBAAuB,EAAC,CAAC;AACtC,OAAO,EAAC,kBAAkB,EAAC,MAAM,mDAAmD,CAAC;AACrF,OAAO,EAAC,OAAO,EAAC,MAAM,wCAAwC,CAAC;AAC/D,OAAO,EAAC,aAAa,EAAC,MAAM,8CAA8C,CAAC;AAC3E,OAAO,EAAC,KAAK,EAAC,MAAM,sCAAsC,CAAC;AAC3D,OAAO,EAAC,KAAK,EAAC,MAAM,sCAAsC,CAAC;AAC3D,OAAO,EAAC,QAAQ,EAAC,MAAM,yCAAyC,CAAC;AACjE,OAAO,EAAC,QAAQ,EAAC,MAAM,yCAAyC,CAAC;AAGjE,OAAO,EAAC,aAAa,EAAC,MAAM,2CAA2C,CAAC;AACxE,OAAO,EAAC,SAAS,EAAC,MAAM,uCAAuC,CAAC;AAChE,OAAO,EAAC,QAAQ,EAAC,MAAM,sCAAsC,CAAC;AAC9D,OAAO,EAAC,iBAAiB,EAAC,MAAM,+CAA+C,CAAC;AAChF,OAAO,EAAC,GAAG,EAAC,MAAM,iCAAiC,CAAC;AACpD,OAAO,EAAC,OAAO,EAAC,MAAM,qCAAqC,CAAC;AAG5D,OAAO,EAAC,UAAU,EAAC,MAAM,yCAAyC,CAAC;AACnE,OAAO,EAAC,KAAK,EAAC,MAAM,oCAAoC,CAAC;AAGzD,OAAO,EAAC,IAAI,EAAC,MAAM,qBAAqB,CAAC;AAGzC,OAAO,EAAC,IAAI,IAAI,KAAK,EAAC,MAAM,mCAAmC,CAAC;AAChE,OAAO,EAAC,SAAS,IAAI,UAAU,EAAC,MAAM,+BAA+B,CAAC;AAEtE,oBAAY,eAAe,GAAG;IAC5B,kBAAkB,CAAC,EAAE,uBAAuB,CAAC;CAC9C,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,YAAY,EAAC,YAAY,EAAC,MAAM,mCAAmC,CAAC;AACpE,YAAY,EAAC,UAAU,EAAC,MAAM,iCAAiC,CAAC;AAEhE,OAAO,EAAC,eAAe,EAAC,MAAM,yCAAyC,CAAC;AAGxE,OAAO,EAAC,cAAc,EAAC,MAAM,sCAAsC,CAAC;AACpE,OAAO,EAAC,qBAAqB,EAAC,MAAM,6CAA6C,CAAC;AAGlF,YAAY,EAAC,eAAe,EAAC,MAAM,qCAAqC,CAAC;AACzE,OAAO,EAAC,iBAAiB,EAAC,MAAM,wCAAwC,CAAC;AAGzE,OAAO,EAAC,aAAa,EAAC,MAAM,kCAAkC,CAAC;AAC/D,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,EAClB,aAAa,EACd,MAAM,+BAA+B,CAAC;AAIvC;;;GAGG;AACH,OAAO,EAAC,IAAI,EAAC,MAAM,4BAA4B,CAAC;AAKhD,OAAO,EAAC,MAAM,EAAC,MAAM,wBAAwB,CAAC;AAG9C,OAAO,EAAC,IAAI,EAAC,MAAM,qBAAqB,CAAC;AACzC,OAAO,EAAC,IAAI,EAAE,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAGzD,OAAO,EAAC,OAAO,EAAC,MAAM,2BAA2B,CAAC;AAClD,OAAO,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAC/C,OAAO,EAAC,QAAQ,EAAC,MAAM,6BAA6B,CAAC;AACrD,OAAO,EAAC,OAAO,EAAC,MAAM,2BAA2B,CAAC;AAClD,OAAO,EAAC,eAAe,EAAE,aAAa,EAAC,MAAM,yCAAyC,CAAC;AACvF,OAAO,EAAC,GAAG,EAAC,MAAM,mBAAmB,CAAC;AAGtC,OAAO,EAAC,SAAS,EAAC,MAAM,wCAAwC,CAAC;AACjE,OAAO,EAAC,YAAY,EAAC,MAAM,2CAA2C,CAAC;AACvE,OAAO,EAAC,QAAQ,EAAC,MAAM,uCAAuC,CAAC;AAG/D,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,mDAAmD,CAAC;AAC/F,YAAY,EAAC,uBAAuB,EAAC,CAAC;AACtC,OAAO,EAAC,kBAAkB,EAAC,MAAM,mDAAmD,CAAC;AACrF,OAAO,EAAC,OAAO,EAAC,MAAM,wCAAwC,CAAC;AAC/D,OAAO,EAAC,aAAa,EAAC,MAAM,8CAA8C,CAAC;AAC3E,OAAO,EAAC,KAAK,EAAC,MAAM,sCAAsC,CAAC;AAC3D,OAAO,EAAC,KAAK,EAAC,MAAM,sCAAsC,CAAC;AAC3D,OAAO,EAAC,QAAQ,EAAC,MAAM,yCAAyC,CAAC;AACjE,OAAO,EAAC,QAAQ,EAAC,MAAM,yCAAyC,CAAC;AAGjE,OAAO,EAAC,aAAa,EAAC,MAAM,2CAA2C,CAAC;AACxE,OAAO,EAAC,SAAS,EAAC,MAAM,uCAAuC,CAAC;AAChE,OAAO,EAAC,QAAQ,EAAC,MAAM,sCAAsC,CAAC;AAC9D,OAAO,EAAC,iBAAiB,EAAC,MAAM,+CAA+C,CAAC;AAChF,OAAO,EAAC,GAAG,EAAC,MAAM,iCAAiC,CAAC;AACpD,OAAO,EAAC,OAAO,EAAC,MAAM,qCAAqC,CAAC;AAG5D,OAAO,EAAC,UAAU,EAAC,MAAM,yCAAyC,CAAC;AACnE,OAAO,EAAC,KAAK,EAAC,MAAM,oCAAoC,CAAC;AAGzD,OAAO,EAAC,IAAI,EAAC,MAAM,qBAAqB,CAAC;AAGzC,OAAO,EAAC,IAAI,IAAI,KAAK,EAAC,MAAM,mCAAmC,CAAC;AAChE,OAAO,EAAC,SAAS,IAAI,UAAU,EAAC,MAAM,+BAA+B,CAAC;AAEtE,oBAAY,eAAe,GAAG;IAC5B,kBAAkB,CAAC,EAAE,uBAAuB,CAAC;CAC9C,CAAA"}

package/dist/index.js

@@ -4,6 +4,7 @@ export { normalizeShaderModule } from './lib/shader-module/normalize-shader-modu
 export { formatCompilerLog } from './lib/compiler-log/format-compiler-log';
 export { getShaderInfo } from './lib/glsl-utils/get-shader-info';
 export { getQualifierDetails, getPassthroughFS, typeToChannelSuffix, typeToChannelCount, convertToVec4 } from './lib/glsl-utils/shader-utils';
+export { glsl } from './lib/glsl-utils/highlight';
 export { random } from './modules/utils/random';
 export { fp32 } from './modules/fp32/fp32';
 export { fp64, fp64arithmetic } from './modules/fp64/fp64';

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"names":["assembleShaders","combineInjects","normalizeShaderModule","formatCompilerLog","getShaderInfo","getQualifierDetails","getPassthroughFS","typeToChannelSuffix","typeToChannelCount","convertToVec4","random","fp32","fp64","fp64arithmetic","project","lights","dirlight","picking","gouraudLighting","phongLighting","pbr","tiltShift","triangleBlur","zoomBlur","brightnessContrast","denoise","hueSaturation","noise","sepia","vibrance","vignette","colorHalftone","dotScreen","edgeWork","hexagonalPixelate","ink","magnify","bulgePinch","swirl","fxaa","warp","_warp","transform","_transform"],"mappings":"AAMA,SAAQA,eAAR,QAA8B,yCAA9B;AAGA,SAAQC,cAAR,QAA6B,sCAA7B;AACA,SAAQC,qBAAR,QAAoC,6CAApC;AAIA,SAAQC,iBAAR,QAAgC,wCAAhC;AAGA,SAAQC,aAAR,QAA4B,kCAA5B;AACA,SACEC,mBADF,EAEEC,gBAFF,EAGEC,mBAHF,EAIEC,kBAJF,EAKEC,aALF,QAMO,+BANP;AAWA,SAAQC,MAAR,QAAqB,wBAArB;AAGA,SAAQC,IAAR,QAAmB,qBAAnB;AACA,SAAQC,IAAR,EAAcC,cAAd,QAAmC,qBAAnC;AAGA,SAAQC,OAAR,QAAsB,2BAAtB;AACA,SAAQC,MAAR,QAAqB,yBAArB;AACA,SAAQC,QAAR,QAAuB,6BAAvB;AACA,SAAQC,OAAR,QAAsB,2BAAtB;AACA,SAAQC,eAAR,EAAyBC,aAAzB,QAA6C,yCAA7C;AACA,SAAQC,GAAR,QAAkB,mBAAlB;AAGA,SAAQC,SAAR,QAAwB,wCAAxB;AACA,SAAQC,YAAR,QAA2B,2CAA3B;AACA,SAAQC,QAAR,QAAuB,uCAAvB;AAKA,SAAQC,kBAAR,QAAiC,mDAAjC;AACA,SAAQC,OAAR,QAAsB,wCAAtB;AACA,SAAQC,aAAR,QAA4B,8CAA5B;AACA,SAAQC,KAAR,QAAoB,sCAApB;AACA,SAAQC,KAAR,QAAoB,sCAApB;AACA,SAAQC,QAAR,QAAuB,yCAAvB;AACA,SAAQC,QAAR,QAAuB,yCAAvB;AAGA,SAAQC,aAAR,QAA4B,2CAA5B;AACA,SAAQC,SAAR,QAAwB,uCAAxB;AACA,SAAQC,QAAR,QAAuB,sCAAvB;AACA,SAAQC,iBAAR,QAAgC,+CAAhC;AACA,SAAQC,GAAR,QAAkB,iCAAlB;AACA,SAAQC,OAAR,QAAsB,qCAAtB;AAGA,SAAQC,UAAR,QAAyB,yCAAzB;AACA,SAAQC,KAAR,QAAoB,oCAApB;AAGA,SAAQC,IAAR,QAAmB,qBAAnB;AAGA,SAAQC,IAAI,IAAIC,KAAhB,QAA4B,mCAA5B;AACA,SAAQC,SAAS,IAAIC,UAArB,QAAsC,+BAAtC","sourcesContent":["// shadertools exports\n\n// DOCUMENTED APIS\nexport type {ShaderModule} from './lib/shader-module/shader-module';\nexport type {ShaderPass} from './lib/shader-module/shader-pass';\n\nexport {assembleShaders} from './lib/shader-assembler/assemble-shaders';\n\n// HELPERS\nexport {combineInjects} from './lib/shader-assembler/inject-shader';\nexport {normalizeShaderModule} from './lib/shader-module/normalize-shader-module';\n\n// COMPILER LOG\nexport type {CompilerMessage} from './lib/compiler-log/compiler-message';\nexport {formatCompilerLog} from './lib/compiler-log/format-compiler-log';\n\n// Shader source introspection\nexport {getShaderInfo} from './lib/glsl-utils/get-shader-info';\nexport {\n  getQualifierDetails,\n  getPassthroughFS,\n  typeToChannelSuffix,\n  typeToChannelCount,\n  convertToVec4\n} from './lib/glsl-utils/shader-utils';\n\n// SHADER MODULES\n\n// utils\nexport {random} from './modules/utils/random';\n\n// math libraries\nexport {fp32} from './modules/fp32/fp32';\nexport {fp64, fp64arithmetic} from './modules/fp64/fp64';\n\n// projection and lighting\nexport {project} from './modules/project/project';\nexport {lights} from './modules/lights/lights';\nexport {dirlight} from './modules/dirlight/dirlight';\nexport {picking} from './modules/picking/picking';\nexport {gouraudLighting, phongLighting} from './modules/phong-lighting/phong-lighting';\nexport {pbr} from './modules/pbr/pbr';\n\n// glfx BLUR shader modules\nexport {tiltShift} from './modules/image-blur-filters/tiltshift';\nexport {triangleBlur} from './modules/image-blur-filters/triangleblur';\nexport {zoomBlur} from './modules/image-blur-filters/zoomblur';\n\n// glfx image adjustment shader modules\nimport type {BrightnessContrastProps} from './modules/image-adjust-filters/brightnesscontrast';\nexport type {BrightnessContrastProps};\nexport {brightnessContrast} from './modules/image-adjust-filters/brightnesscontrast';\nexport {denoise} from './modules/image-adjust-filters/denoise';\nexport {hueSaturation} from './modules/image-adjust-filters/huesaturation';\nexport {noise} from './modules/image-adjust-filters/noise';\nexport {sepia} from './modules/image-adjust-filters/sepia';\nexport {vibrance} from './modules/image-adjust-filters/vibrance';\nexport {vignette} from './modules/image-adjust-filters/vignette';\n\n// glfx FUN shader modules\nexport {colorHalftone} from './modules/image-fun-filters/colorhalftone';\nexport {dotScreen} from './modules/image-fun-filters/dotscreen';\nexport {edgeWork} from './modules/image-fun-filters/edgework';\nexport {hexagonalPixelate} from './modules/image-fun-filters/hexagonalpixelate';\nexport {ink} from './modules/image-fun-filters/ink';\nexport {magnify} from './modules/image-fun-filters/magnify';\n\n// glfx WARP shader modules\nexport {bulgePinch} from './modules/image-warp-filters/bulgepinch';\nexport {swirl} from './modules/image-warp-filters/swirl';\n\n// Postprocessing\nexport {fxaa} from './modules/fxaa/fxaa';\n\n// experimental\nexport {warp as _warp} from './modules/image-warp-filters/warp';\nexport {transform as _transform} from './modules/transform/transform';\n\nexport type ShaderPassProps = {\n  brightnessContrast?: BrightnessContrastProps;\n}"],"file":"index.js"}
+{"version":3,"sources":["../src/index.ts"],"names":["assembleShaders","combineInjects","normalizeShaderModule","formatCompilerLog","getShaderInfo","getQualifierDetails","getPassthroughFS","typeToChannelSuffix","typeToChannelCount","convertToVec4","glsl","random","fp32","fp64","fp64arithmetic","project","lights","dirlight","picking","gouraudLighting","phongLighting","pbr","tiltShift","triangleBlur","zoomBlur","brightnessContrast","denoise","hueSaturation","noise","sepia","vibrance","vignette","colorHalftone","dotScreen","edgeWork","hexagonalPixelate","ink","magnify","bulgePinch","swirl","fxaa","warp","_warp","transform","_transform"],"mappings":"AAMA,SAAQA,eAAR,QAA8B,yCAA9B;AAGA,SAAQC,cAAR,QAA6B,sCAA7B;AACA,SAAQC,qBAAR,QAAoC,6CAApC;AAIA,SAAQC,iBAAR,QAAgC,wCAAhC;AAGA,SAAQC,aAAR,QAA4B,kCAA5B;AACA,SACEC,mBADF,EAEEC,gBAFF,EAGEC,mBAHF,EAIEC,kBAJF,EAKEC,aALF,QAMO,+BANP;AAcA,SAAQC,IAAR,QAAmB,4BAAnB;AAKA,SAAQC,MAAR,QAAqB,wBAArB;AAGA,SAAQC,IAAR,QAAmB,qBAAnB;AACA,SAAQC,IAAR,EAAcC,cAAd,QAAmC,qBAAnC;AAGA,SAAQC,OAAR,QAAsB,2BAAtB;AACA,SAAQC,MAAR,QAAqB,yBAArB;AACA,SAAQC,QAAR,QAAuB,6BAAvB;AACA,SAAQC,OAAR,QAAsB,2BAAtB;AACA,SAAQC,eAAR,EAAyBC,aAAzB,QAA6C,yCAA7C;AACA,SAAQC,GAAR,QAAkB,mBAAlB;AAGA,SAAQC,SAAR,QAAwB,wCAAxB;AACA,SAAQC,YAAR,QAA2B,2CAA3B;AACA,SAAQC,QAAR,QAAuB,uCAAvB;AAKA,SAAQC,kBAAR,QAAiC,mDAAjC;AACA,SAAQC,OAAR,QAAsB,wCAAtB;AACA,SAAQC,aAAR,QAA4B,8CAA5B;AACA,SAAQC,KAAR,QAAoB,sCAApB;AACA,SAAQC,KAAR,QAAoB,sCAApB;AACA,SAAQC,QAAR,QAAuB,yCAAvB;AACA,SAAQC,QAAR,QAAuB,yCAAvB;AAGA,SAAQC,aAAR,QAA4B,2CAA5B;AACA,SAAQC,SAAR,QAAwB,uCAAxB;AACA,SAAQC,QAAR,QAAuB,sCAAvB;AACA,SAAQC,iBAAR,QAAgC,+CAAhC;AACA,SAAQC,GAAR,QAAkB,iCAAlB;AACA,SAAQC,OAAR,QAAsB,qCAAtB;AAGA,SAAQC,UAAR,QAAyB,yCAAzB;AACA,SAAQC,KAAR,QAAoB,oCAApB;AAGA,SAAQC,IAAR,QAAmB,qBAAnB;AAGA,SAAQC,IAAI,IAAIC,KAAhB,QAA4B,mCAA5B;AACA,SAAQC,SAAS,IAAIC,UAArB,QAAsC,+BAAtC","sourcesContent":["// shadertools exports\n\n// DOCUMENTED APIS\nexport type {ShaderModule} from './lib/shader-module/shader-module';\nexport type {ShaderPass} from './lib/shader-module/shader-pass';\n\nexport {assembleShaders} from './lib/shader-assembler/assemble-shaders';\n\n// HELPERS\nexport {combineInjects} from './lib/shader-assembler/inject-shader';\nexport {normalizeShaderModule} from './lib/shader-module/normalize-shader-module';\n\n// COMPILER LOG\nexport type {CompilerMessage} from './lib/compiler-log/compiler-message';\nexport {formatCompilerLog} from './lib/compiler-log/format-compiler-log';\n\n// Shader source introspection\nexport {getShaderInfo} from './lib/glsl-utils/get-shader-info';\nexport {\n  getQualifierDetails,\n  getPassthroughFS,\n  typeToChannelSuffix,\n  typeToChannelCount,\n  convertToVec4\n} from './lib/glsl-utils/shader-utils';\n\n// SHADER HELPERS\n\n/**\n * Marks GLSL shaders for syntax highlighting: glsl`...`\n * Install https://marketplace.visualstudio.com/items?itemName=boyswan.glsl-literal\n */\nexport {glsl} from './lib/glsl-utils/highlight';\n\n// SHADER MODULES\n\n// utils\nexport {random} from './modules/utils/random';\n\n// math libraries\nexport {fp32} from './modules/fp32/fp32';\nexport {fp64, fp64arithmetic} from './modules/fp64/fp64';\n\n// projection and lighting\nexport {project} from './modules/project/project';\nexport {lights} from './modules/lights/lights';\nexport {dirlight} from './modules/dirlight/dirlight';\nexport {picking} from './modules/picking/picking';\nexport {gouraudLighting, phongLighting} from './modules/phong-lighting/phong-lighting';\nexport {pbr} from './modules/pbr/pbr';\n\n// glfx BLUR shader modules\nexport {tiltShift} from './modules/image-blur-filters/tiltshift';\nexport {triangleBlur} from './modules/image-blur-filters/triangleblur';\nexport {zoomBlur} from './modules/image-blur-filters/zoomblur';\n\n// glfx image adjustment shader modules\nimport type {BrightnessContrastProps} from './modules/image-adjust-filters/brightnesscontrast';\nexport type {BrightnessContrastProps};\nexport {brightnessContrast} from './modules/image-adjust-filters/brightnesscontrast';\nexport {denoise} from './modules/image-adjust-filters/denoise';\nexport {hueSaturation} from './modules/image-adjust-filters/huesaturation';\nexport {noise} from './modules/image-adjust-filters/noise';\nexport {sepia} from './modules/image-adjust-filters/sepia';\nexport {vibrance} from './modules/image-adjust-filters/vibrance';\nexport {vignette} from './modules/image-adjust-filters/vignette';\n\n// glfx FUN shader modules\nexport {colorHalftone} from './modules/image-fun-filters/colorhalftone';\nexport {dotScreen} from './modules/image-fun-filters/dotscreen';\nexport {edgeWork} from './modules/image-fun-filters/edgework';\nexport {hexagonalPixelate} from './modules/image-fun-filters/hexagonalpixelate';\nexport {ink} from './modules/image-fun-filters/ink';\nexport {magnify} from './modules/image-fun-filters/magnify';\n\n// glfx WARP shader modules\nexport {bulgePinch} from './modules/image-warp-filters/bulgepinch';\nexport {swirl} from './modules/image-warp-filters/swirl';\n\n// Postprocessing\nexport {fxaa} from './modules/fxaa/fxaa';\n\n// experimental\nexport {warp as _warp} from './modules/image-warp-filters/warp';\nexport {transform as _transform} from './modules/transform/transform';\n\nexport type ShaderPassProps = {\n  brightnessContrast?: BrightnessContrastProps;\n}"],"file":"index.js"}

package/dist/lib/glsl-utils/highlight.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Marks GLSL shaders for syntax highlighting: glsl`...`
+ * Install https://marketplace.visualstudio.com/items?itemName=boyswan.glsl-literal
+ */
+export declare const glsl: (x: TemplateStringsArray) => string;
+//# sourceMappingURL=highlight.d.ts.map

package/dist/lib/glsl-utils/highlight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"highlight.d.ts","sourceRoot":"","sources":["../../../src/lib/glsl-utils/highlight.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,IAAI,MAAO,oBAAoB,WAAW,CAAC"}

package/dist/lib/glsl-utils/highlight.js

@@ -0,0 +1,2 @@
+export const glsl = x => "".concat(x);
+//# sourceMappingURL=highlight.js.map

package/dist/lib/glsl-utils/highlight.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/glsl-utils/highlight.ts"],"names":["glsl","x"],"mappings":"AAMA,OAAO,MAAMA,IAAI,GAAIC,CAAD,cAAgCA,CAAhC,CAAb","sourcesContent":["// SHADER HELPERS\n\n/**\n * Marks GLSL shaders for syntax highlighting: glsl`...`\n * Install https://marketplace.visualstudio.com/items?itemName=boyswan.glsl-literal\n */\nexport const glsl = (x: TemplateStringsArray) => `${x}`;\n"],"file":"highlight.js"}

package/dist/lib/glsl-utils/shader-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/glsl-utils/shader-utils.ts"],"names":[],"mappings":"AASA,aAAK,aAAa,GAAG;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAA;AAGD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,aAAa,GAAG,IAAI,CAUrG;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,MAAM,CAiCT;AAED,kCAAkC;AAClC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAI,GAAG,GAAG,IAAI,GAAG,KAAK,GAAG,MAAM,CAU9E;AAED,yCAAyC;AACzC,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAU9D;AAED,sDAAsD;AACtD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAUpE"}
+{"version":3,"file":"shader-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/glsl-utils/shader-utils.ts"],"names":[],"mappings":"AAWA,aAAK,aAAa,GAAG;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAA;AAGD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,aAAa,GAAG,IAAI,CAUrG;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,MAAM,CAiCT;AAED,kCAAkC;AAClC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAI,GAAG,GAAG,IAAI,GAAG,KAAK,GAAG,MAAM,CAU9E;AAED,yCAAyC;AACzC,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAU9D;AAED,sDAAsD;AACtD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAUpE"}

package/dist/lib/glsl-utils/shader-utils.js

@@ -1,5 +1,10 @@
-const FS100 = "void main() {gl_FragColor = vec4(0);}";
-const FS_GLES = "out vec4 transform_output;\nvoid main() {\n  transform_output = vec4(0);\n}";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+
+var _templateObject, _templateObject2;
+
+import { glsl } from './highlight';
+const FS100 = glsl(_templateObject || (_templateObject = _taggedTemplateLiteral(["void main() {gl_FragColor = vec4(0);}"])));
+const FS_GLES = glsl(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["out vec4 transform_output;\nvoid main() {\n  transform_output = vec4(0);\n}"], ["\\\nout vec4 transform_output;\nvoid main() {\n  transform_output = vec4(0);\n}"])));
 const FS300 = "#version 300 es\n".concat(FS_GLES);
 export function getQualifierDetails(line, qualifiers) {
   qualifiers = Array.isArray(qualifiers) ? qualifiers : [qualifiers];

package/dist/lib/glsl-utils/shader-utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/glsl-utils/shader-utils.ts"],"names":["FS100","FS_GLES","FS300","getQualifierDetails","line","qualifiers","Array","isArray","words","replace","split","qualifier","type","definition","includes","name","getPassthroughFS","options","version","input","inputType","output","Error","outputValue","convertToVec4","typeToChannelSuffix","typeToChannelCount","variable"],"mappings":"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","sourcesContent":["// luma.gl, MIT license\nconst FS100 = `void main() {gl_FragColor = vec4(0);}`;\nconst FS_GLES = `\\\nout vec4 transform_output;\nvoid main() {\n  transform_output = vec4(0);\n}`;\nconst FS300 = `#version 300 es\\n${FS_GLES}`;\n\ntype QualifierInfo = {\n  qualifier: string;\n  type: string;\n  name: string;\n}\n\n// Prase given glsl line and return qualifier details or null\nexport function getQualifierDetails(line: string, qualifiers: string | string[]): QualifierInfo | null {\n  qualifiers = Array.isArray(qualifiers) ? qualifiers : [qualifiers];\n  const words = line.replace(/^\\s+/, '').split(/\\s+/);\n  // TODO add support for precession qualifiers (highp, mediump and lowp)\n  const [qualifier, type, definition] = words;\n  if (!qualifiers.includes(qualifier) || !type || !definition) {\n    return null;\n  }\n  const name = definition.split(';')[0];\n  return {qualifier, type, name};\n}\n\n/**\n * Given the shader version, input and output variable names,\n * builds and return a pass through fragment shader.\n */\nexport function getPassthroughFS(options?: {\n  version?: number;\n  input?: string;\n  inputType?: string;\n  output?: string;\n}): string {\n  const {version = 100, input, inputType, output} = options || {};\n  if (!input) {\n    if (version === 300) {\n      // Fast-path for WebGL 2.0\n      return FS300;\n    } else if (version > 300) {\n      // Use the supplied version for OpenGL/ES 3.2+\n      return `#version ${version}\\n${FS_GLES}`;\n    }\n    // Fast-path for WebGL 1.0\n    return FS100;\n  }\n  if (!inputType) {\n    throw new Error('inputType');\n  }\n  const outputValue = convertToVec4(input, inputType);\n  if (version >= 300) {\n    // If version is 300, assume WebGL 2.0\n    return `\\\n#version ${version} ${version === 300 ? 'es' : ''}\nin ${inputType} ${input};\nout vec4 ${output};\nvoid main() {\n  ${output} = ${outputValue};\n}`;\n  }\n  // WebGL 1.0\n  return `\\\nvarying ${inputType} ${input};\nvoid main() {\n  gl_FragColor = ${outputValue};\n}`;\n}\n\n/** convert glsl type to suffix */\nexport function typeToChannelSuffix(type: string):  'x' | 'xy' | 'xyz' | 'xyzw' {\n  // prettier-ignore\n  switch (type) {\n    case 'float': return 'x';\n    case 'vec2': return 'xy';\n    case 'vec3': return 'xyz';\n    case 'vec4': return 'xyzw';\n    default:\n      throw new Error(type);\n  }\n}\n\n/** convert glsl type to channel count */\nexport function typeToChannelCount(type: string): 1 | 2 | 3 | 4 {\n  // prettier-ignore\n  switch (type) {\n    case 'float': return 1;\n    case 'vec2': return 2;\n    case 'vec3': return 3;\n    case 'vec4': return 4;\n    default:\n      throw new Error(type);\n  }\n}\n\n/** Returns glsl instruction for converting to vec4 */\nexport function convertToVec4(variable: string, type: string): string {\n  // prettier-ignore\n  switch (type) {\n    case 'float': return `vec4(${variable}, 0.0, 0.0, 1.0)`;\n    case 'vec2': return `vec4(${variable}, 0.0, 1.0)`;\n    case 'vec3': return `vec4(${variable}, 1.0)`;\n    case 'vec4': return variable;\n    default:\n      throw new Error(type);\n  }\n}\n"],"file":"shader-utils.js"}
+{"version":3,"sources":["../../../src/lib/glsl-utils/shader-utils.ts"],"names":["glsl","FS100","FS_GLES","FS300","getQualifierDetails","line","qualifiers","Array","isArray","words","replace","split","qualifier","type","definition","includes","name","getPassthroughFS","options","version","input","inputType","output","Error","outputValue","convertToVec4","typeToChannelSuffix","typeToChannelCount","variable"],"mappings":";;;;AACA,SAAQA,IAAR,QAAmB,aAAnB;AAEA,MAAMC,KAAK,GAAGD,IAAH,0GAAX;AACA,MAAME,OAAO,GAAGF,IAAH,uOAAb;AAKA,MAAMG,KAAK,8BAAuBD,OAAvB,CAAX;AASA,OAAO,SAASE,mBAAT,CAA6BC,IAA7B,EAA2CC,UAA3C,EAAgG;AACrGA,EAAAA,UAAU,GAAGC,KAAK,CAACC,OAAN,CAAcF,UAAd,IAA4BA,UAA5B,GAAyC,CAACA,UAAD,CAAtD;AACA,QAAMG,KAAK,GAAGJ,IAAI,CAACK,OAAL,CAAa,MAAb,EAAqB,EAArB,EAAyBC,KAAzB,CAA+B,KAA/B,CAAd;AAEA,QAAM,CAACC,SAAD,EAAYC,IAAZ,EAAkBC,UAAlB,IAAgCL,KAAtC;;AACA,MAAI,CAACH,UAAU,CAACS,QAAX,CAAoBH,SAApB,CAAD,IAAmC,CAACC,IAApC,IAA4C,CAACC,UAAjD,EAA6D;AAC3D,WAAO,IAAP;AACD;;AACD,QAAME,IAAI,GAAGF,UAAU,CAACH,KAAX,CAAiB,GAAjB,EAAsB,CAAtB,CAAb;AACA,SAAO;AAACC,IAAAA,SAAD;AAAYC,IAAAA,IAAZ;AAAkBG,IAAAA;AAAlB,GAAP;AACD;AAMD,OAAO,SAASC,gBAAT,CAA0BC,OAA1B,EAKI;AACT,QAAM;AAACC,IAAAA,OAAO,GAAG,GAAX;AAAgBC,IAAAA,KAAhB;AAAuBC,IAAAA,SAAvB;AAAkCC,IAAAA;AAAlC,MAA4CJ,OAAO,IAAI,EAA7D;;AACA,MAAI,CAACE,KAAL,EAAY;AACV,QAAID,OAAO,KAAK,GAAhB,EAAqB;AAEnB,aAAOhB,KAAP;AACD,KAHD,MAGO,IAAIgB,OAAO,GAAG,GAAd,EAAmB;AAExB,gCAAmBA,OAAnB,eAA+BjB,OAA/B;AACD;;AAED,WAAOD,KAAP;AACD;;AACD,MAAI,CAACoB,SAAL,EAAgB;AACd,UAAM,IAAIE,KAAJ,CAAU,WAAV,CAAN;AACD;;AACD,QAAMC,WAAW,GAAGC,aAAa,CAACL,KAAD,EAAQC,SAAR,CAAjC;;AACA,MAAIF,OAAO,IAAI,GAAf,EAAoB;AAElB,8BACOA,OADP,cACkBA,OAAO,KAAK,GAAZ,GAAkB,IAAlB,GAAyB,EAD3C,kBAECE,SAFD,cAEcD,KAFd,yBAGOE,MAHP,iCAKAA,MALA,gBAKYE,WALZ;AAOD;;AAED,2BACQH,SADR,cACqBD,KADrB,gDAGiBI,WAHjB;AAKD;AAGD,OAAO,SAASE,mBAAT,CAA6Bb,IAA7B,EAAyE;AAE9E,UAAQA,IAAR;AACE,SAAK,OAAL;AAAc,aAAO,GAAP;;AACd,SAAK,MAAL;AAAa,aAAO,IAAP;;AACb,SAAK,MAAL;AAAa,aAAO,KAAP;;AACb,SAAK,MAAL;AAAa,aAAO,MAAP;;AACb;AACE,YAAM,IAAIU,KAAJ,CAAUV,IAAV,CAAN;AANJ;AAQD;AAGD,OAAO,SAASc,kBAAT,CAA4Bd,IAA5B,EAAyD;AAE9D,UAAQA,IAAR;AACE,SAAK,OAAL;AAAc,aAAO,CAAP;;AACd,SAAK,MAAL;AAAa,aAAO,CAAP;;AACb,SAAK,MAAL;AAAa,aAAO,CAAP;;AACb,SAAK,MAAL;AAAa,aAAO,CAAP;;AACb;AACE,YAAM,IAAIU,KAAJ,CAAUV,IAAV,CAAN;AANJ;AAQD;AAGD,OAAO,SAASY,aAAT,CAAuBG,QAAvB,EAAyCf,IAAzC,EAA+D;AAEpE,UAAQA,IAAR;AACE,SAAK,OAAL;AAAc,4BAAee,QAAf;;AACd,SAAK,MAAL;AAAa,4BAAeA,QAAf;;AACb,SAAK,MAAL;AAAa,4BAAeA,QAAf;;AACb,SAAK,MAAL;AAAa,aAAOA,QAAP;;AACb;AACE,YAAM,IAAIL,KAAJ,CAAUV,IAAV,CAAN;AANJ;AAQD","sourcesContent":["// luma.gl, MIT license\nimport {glsl} from './highlight';\n\nconst FS100 = glsl`void main() {gl_FragColor = vec4(0);}`;\nconst FS_GLES = glsl`\\\nout vec4 transform_output;\nvoid main() {\n  transform_output = vec4(0);\n}`;\nconst FS300 = `#version 300 es\\n${FS_GLES}`;\n\ntype QualifierInfo = {\n  qualifier: string;\n  type: string;\n  name: string;\n}\n\n// Prase given glsl line and return qualifier details or null\nexport function getQualifierDetails(line: string, qualifiers: string | string[]): QualifierInfo | null {\n  qualifiers = Array.isArray(qualifiers) ? qualifiers : [qualifiers];\n  const words = line.replace(/^\\s+/, '').split(/\\s+/);\n  // TODO add support for precession qualifiers (highp, mediump and lowp)\n  const [qualifier, type, definition] = words;\n  if (!qualifiers.includes(qualifier) || !type || !definition) {\n    return null;\n  }\n  const name = definition.split(';')[0];\n  return {qualifier, type, name};\n}\n\n/**\n * Given the shader version, input and output variable names,\n * builds and return a pass through fragment shader.\n */\nexport function getPassthroughFS(options?: {\n  version?: number;\n  input?: string;\n  inputType?: string;\n  output?: string;\n}): string {\n  const {version = 100, input, inputType, output} = options || {};\n  if (!input) {\n    if (version === 300) {\n      // Fast-path for WebGL 2.0\n      return FS300;\n    } else if (version > 300) {\n      // Use the supplied version for OpenGL/ES 3.2+\n      return `#version ${version}\\n${FS_GLES}`;\n    }\n    // Fast-path for WebGL 1.0\n    return FS100;\n  }\n  if (!inputType) {\n    throw new Error('inputType');\n  }\n  const outputValue = convertToVec4(input, inputType);\n  if (version >= 300) {\n    // If version is 300, assume WebGL 2.0\n    return `\\\n#version ${version} ${version === 300 ? 'es' : ''}\nin ${inputType} ${input};\nout vec4 ${output};\nvoid main() {\n  ${output} = ${outputValue};\n}`;\n  }\n  // WebGL 1.0\n  return `\\\nvarying ${inputType} ${input};\nvoid main() {\n  gl_FragColor = ${outputValue};\n}`;\n}\n\n/** convert glsl type to suffix */\nexport function typeToChannelSuffix(type: string):  'x' | 'xy' | 'xyz' | 'xyzw' {\n  // prettier-ignore\n  switch (type) {\n    case 'float': return 'x';\n    case 'vec2': return 'xy';\n    case 'vec3': return 'xyz';\n    case 'vec4': return 'xyzw';\n    default:\n      throw new Error(type);\n  }\n}\n\n/** convert glsl type to channel count */\nexport function typeToChannelCount(type: string): 1 | 2 | 3 | 4 {\n  // prettier-ignore\n  switch (type) {\n    case 'float': return 1;\n    case 'vec2': return 2;\n    case 'vec3': return 3;\n    case 'vec4': return 4;\n    default:\n      throw new Error(type);\n  }\n}\n\n/** Returns glsl instruction for converting to vec4 */\nexport function convertToVec4(variable: string, type: string): string {\n  // prettier-ignore\n  switch (type) {\n    case 'float': return `vec4(${variable}, 0.0, 0.0, 1.0)`;\n    case 'vec2': return `vec4(${variable}, 0.0, 1.0)`;\n    case 'vec3': return `vec4(${variable}, 1.0)`;\n    case 'vec4': return variable;\n    default:\n      throw new Error(type);\n  }\n}\n"],"file":"shader-utils.js"}

package/dist/lib/shader-assembler/assemble-shaders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assemble-shaders.d.ts","sourceRoot":"","sources":["../../../src/lib/shader-assembler/assemble-shaders.ts"],"names":[],"mappings":"AACA,OAAO,EAA8C,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAwB7F,iBAAiB;AACjB,aAAK,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;AAEzD,oBAAY,YAAY,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC;AAE/F,oBAAY,qBAAqB,GAAG;IAClC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,aAAa,CAAC,EAAE,CAAC,YAAY,GAAG,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;KAAE,CAAC,EAAE,CAAC;IAC9F,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,GAAG,CAAC,EAAE,GAAG,CAAC;CACX,CAAC;AAEF;;GAEG;AACH,wBAAgB,eAAe,CAC7B,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,qBAAqB,GAC7B;IACD,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,GAAG,CAAC;CAClB,CAQA"}
+{"version":3,"file":"assemble-shaders.d.ts","sourceRoot":"","sources":["../../../src/lib/shader-assembler/assemble-shaders.ts"],"names":[],"mappings":"AAGA,OAAO,EAA8C,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAwB7F,iBAAiB;AACjB,aAAK,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;AAEzD,oBAAY,YAAY,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC;AAE/F,oBAAY,qBAAqB,GAAG;IAClC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,aAAa,CAAC,EAAE,CAAC,YAAY,GAAG,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;KAAE,CAAC,EAAE,CAAC;IAC9F,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,GAAG,CAAC,EAAE,GAAG,CAAC;CACX,CAAC;AAEF;;GAEG;AACH,wBAAgB,eAAe,CAC7B,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,qBAAqB,GAC7B;IACD,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,GAAG,CAAC;CAClB,CAQA"}

package/dist/lib/shader-assembler/assemble-shaders.js

@@ -1,3 +1,8 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+
+var _templateObject;
+
+import { glsl } from '../glsl-utils/highlight';
 import { resolveModules } from './resolve-modules';
 import { getPlatformShaderDefines, getVersionDefines } from './platform-defines';
 import injectShader, { DECLARATION_INJECT_MARKER } from './inject-shader';
@@ -8,7 +13,7 @@ const SHADER_TYPE = {
   'fs': 'fragment',
   'vs': 'vertex'
 };
-const FRAGMENT_SHADER_PROLOGUE = "precision highp float;\n\n";
+const FRAGMENT_SHADER_PROLOGUE = glsl(_templateObject || (_templateObject = _taggedTemplateLiteral(["precision highp float;\n\n"], ["\\\nprecision highp float;\n\n"])));
 export function assembleShaders(platformInfo, options) {
   const {
     vs,

package/dist/lib/shader-assembler/assemble-shaders.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/shader-assembler/assemble-shaders.ts"],"names":["resolveModules","getPlatformShaderDefines","getVersionDefines","injectShader","DECLARATION_INJECT_MARKER","transpileShader","assert","INJECT_SHADER_DECLARATIONS","SHADER_TYPE","FRAGMENT_SHADER_PROLOGUE","assembleShaders","platformInfo","options","vs","fs","modules","assembleShader","source","type","getUniforms","assembleGetUniforms","id","defines","hookFunctions","inject","transpileToGLSL100","prologue","log","isVertex","sourceLines","split","glslVersion","versionLine","coreSource","indexOf","slice","join","allDefines","forEach","module","Object","assign","getDefines","assembledSource","getShaderNameDefine","getShaderType","getApplicationDefines","hookFunctionMap","normalizeHookFunctions","hookInjections","declInjections","mainInjections","key","injection","order","match","hash","name","checkDeprecations","moduleSource","getModuleSource","injections","injectionType","push","getHookFunctions","opts","uniforms","moduleUniforms","toUpperCase","injectShaderName","count","sourceText","define","value","Number","isFinite","result","hookName","hookFunction","signature","header","sort","a","b","footer","hook","trim","stage","replace","Error"],"mappings":"AAAA,SAAQA,cAAR,QAA6B,mBAA7B;AACA,SAAQC,wBAAR,EAAkCC,iBAAlC,QAAwE,oBAAxE;AACA,OAAOC,YAAP,IAAsBC,yBAAtB,QAAsD,iBAAtD;AACA,OAAOC,eAAP,MAA4B,gCAA5B;AACA,SAAQC,MAAR,QAAqB,iBAArB;AAKA,MAAMC,0BAA0B,iBAAUH,yBAAV,SAAhC;AAEA,MAAMI,WAAW,GAAG;AAClB,QAAM,UADY;AAElB,QAAM;AAFY,CAApB;AASA,MAAMC,wBAAwB,+BAA9B;AA2BA,OAAO,SAASC,eAAT,CACLC,YADK,EAELC,OAFK,EAOL;AACA,QAAM;AAACC,IAAAA,EAAD;AAAKC,IAAAA;AAAL,MAAWF,OAAjB;AACA,QAAMG,OAAO,GAAGf,cAAc,CAACY,OAAO,CAACG,OAAR,IAAmB,EAApB,CAA9B;AACA,SAAO;AACLF,IAAAA,EAAE,EAAEG,cAAc,CAACL,YAAD,EAAe,EAAC,GAAGC,OAAJ;AAAaK,MAAAA,MAAM,EAAEJ,EAArB;AAAyBK,MAAAA,IAAI,EAAE,IAA/B;AAAqCH,MAAAA;AAArC,KAAf,CADb;AAELD,IAAAA,EAAE,EAAEE,cAAc,CAACL,YAAD,EAAe,EAAC,GAAGC,OAAJ;AAAaK,MAAAA,MAAM,EAAEH,EAArB;AAAyBI,MAAAA,IAAI,EAAE,IAA/B;AAAqCH,MAAAA;AAArC,KAAf,CAFb;AAGLI,IAAAA,WAAW,EAAEC,mBAAmB,CAACL,OAAD;AAH3B,GAAP;AAKD;;AASD,SAASC,cAAT,CACEL,YADF,EAEEC,OAFF,EAcE;AACA,QAAM;AACJS,IAAAA,EADI;AAEJJ,IAAAA,MAFI;AAGJC,IAAAA,IAHI;AAIJH,IAAAA,OAJI;AAKJO,IAAAA,OAAO,GAAG,EALN;AAMJC,IAAAA,aAAa,GAAG,EANZ;AAOJC,IAAAA,MAAM,GAAG,EAPL;AAQJC,IAAAA,kBAAkB,GAAG,KARjB;AASJC,IAAAA,QAAQ,GAAG,IATP;AAUJC,IAAAA;AAVI,MAWFf,OAXJ;AAaAN,EAAAA,MAAM,CAAC,OAAOW,MAAP,KAAkB,QAAnB,EAA6B,gCAA7B,CAAN;AAEA,QAAMW,QAAQ,GAAGV,IAAI,KAAK,IAA1B;AAEA,QAAMW,WAAW,GAAGZ,MAAM,CAACa,KAAP,CAAa,IAAb,CAApB;AACA,MAAIC,WAAW,GAAG,GAAlB;AACA,MAAIC,WAAW,GAAG,EAAlB;AACA,MAAIC,UAAU,GAAGhB,MAAjB;;AAGA,MAAIY,WAAW,CAAC,CAAD,CAAX,CAAeK,OAAf,CAAuB,WAAvB,MAAwC,CAA5C,EAA+C;AAC7CH,IAAAA,WAAW,GAAG,GAAd;AACAC,IAAAA,WAAW,GAAGH,WAAW,CAAC,CAAD,CAAzB;AACAI,IAAAA,UAAU,GAAGJ,WAAW,CAACM,KAAZ,CAAkB,CAAlB,EAAqBC,IAArB,CAA0B,IAA1B,CAAb;AACD,GAJD,MAIO;AACLJ,IAAAA,WAAW,sBAAeD,WAAf,CAAX;AACD;;AAGD,QAAMM,UAAU,GAAG,EAAnB;AACAtB,EAAAA,OAAO,CAACuB,OAAR,CAAiBC,MAAD,IAAY;AAC1BC,IAAAA,MAAM,CAACC,MAAP,CAAcJ,UAAd,EAA0BE,MAAM,CAACG,UAAP,EAA1B;AACD,GAFD;AAGAF,EAAAA,MAAM,CAACC,MAAP,CAAcJ,UAAd,EAA0Bf,OAA1B;AAKA,MAAIqB,eAAe,GAAGjB,QAAQ,aAE9BM,WAF8B,eAG9BY,mBAAmB,CAAC;AAACvB,IAAAA,EAAD;AAAKJ,IAAAA,MAAL;AAAaC,IAAAA;AAAb,GAAD,CAHW,eAI9B2B,aAAa,CAAC3B,IAAD,CAJiB,eAK9BjB,wBAAwB,CAACU,YAAD,CALM,eAM9BT,iBAAiB,CAACS,YAAD,CANa,eAO9BmC,qBAAqB,CAACT,UAAD,CAPS,eAQ9BT,QAAQ,GAAG,EAAH,GAAQnB,wBARc,oBAUvBuB,WAVuB,OAA9B;AAaA,QAAMe,eAAe,GAAGC,sBAAsB,CAACzB,aAAD,CAA9C;AAGA,QAAM0B,cAA2C,GAAG,EAApD;AACA,QAAMC,cAA2C,GAAG,EAApD;AACA,QAAMC,cAA2C,GAAG,EAApD;;AAEA,OAAK,MAAMC,GAAX,IAAkB5B,MAAlB,EAA0B;AACxB,UAAM6B,SAAS,GACb,OAAO7B,MAAM,CAAC4B,GAAD,CAAb,KAAuB,QAAvB,GAAkC;AAACC,MAAAA,SAAS,EAAE7B,MAAM,CAAC4B,GAAD,CAAlB;AAAyBE,MAAAA,KAAK,EAAE;AAAhC,KAAlC,GAAuE9B,MAAM,CAAC4B,GAAD,CAD/E;AAEA,UAAMG,KAAK,GAAGH,GAAG,CAACG,KAAJ,CAAU,uBAAV,CAAd;;AACA,QAAIA,KAAJ,EAAW;AACT,YAAMC,IAAI,GAAGD,KAAK,CAAC,CAAD,CAAlB;AACA,YAAME,IAAI,GAAGF,KAAK,CAAC,CAAD,CAAlB;;AACA,UAAIC,IAAJ,EAAU;AACR,YAAIC,IAAI,KAAK,MAAb,EAAqB;AACnBP,UAAAA,cAAc,CAACE,GAAD,CAAd,GAAsB,CAACC,SAAD,CAAtB;AACD,SAFD,MAEO;AACLF,UAAAA,cAAc,CAACC,GAAD,CAAd,GAAsB,CAACC,SAAD,CAAtB;AACD;AACF,OAND,MAMO;AACLJ,QAAAA,cAAc,CAACG,GAAD,CAAd,GAAsB,CAACC,SAAD,CAAtB;AACD;AACF,KAZD,MAYO;AAELF,MAAAA,cAAc,CAACC,GAAD,CAAd,GAAsB,CAACC,SAAD,CAAtB;AACD;AACF;;AAED,OAAK,MAAMd,MAAX,IAAqBxB,OAArB,EAA8B;AAC5B,QAAIY,GAAJ,EAAS;AACPY,MAAAA,MAAM,CAACmB,iBAAP,CAAyBzB,UAAzB,EAAqCN,GAArC;AACD;;AACD,UAAMgC,YAAY,GAAGpB,MAAM,CAACqB,eAAP,CAAuB1C,IAAvB,EAA6Ba,WAA7B,CAArB;AAEAY,IAAAA,eAAe,IAAIgB,YAAnB;AAEA,UAAME,UAAU,GAAGtB,MAAM,CAACsB,UAAP,CAAkB3C,IAAlB,CAAnB;;AACA,SAAK,MAAMkC,GAAX,IAAkBS,UAAlB,EAA8B;AAC5B,YAAMN,KAAK,GAAGH,GAAG,CAACG,KAAJ,CAAU,oBAAV,CAAd;;AACA,UAAIA,KAAJ,EAAW;AACT,cAAME,IAAI,GAAGF,KAAK,CAAC,CAAD,CAAlB;AACA,cAAMO,aAAa,GAAGL,IAAI,KAAK,MAAT,GAAkBP,cAAlB,GAAmCC,cAAzD;AACAW,QAAAA,aAAa,CAACV,GAAD,CAAb,GAAqBU,aAAa,CAACV,GAAD,CAAb,IAAsB,EAA3C;AACAU,QAAAA,aAAa,CAACV,GAAD,CAAb,CAAmBW,IAAnB,CAAwBF,UAAU,CAACT,GAAD,CAAlC;AACD,OALD,MAKO;AACLH,QAAAA,cAAc,CAACG,GAAD,CAAd,GAAsBH,cAAc,CAACG,GAAD,CAAd,IAAuB,EAA7C;AACAH,QAAAA,cAAc,CAACG,GAAD,CAAd,CAAoBW,IAApB,CAAyBF,UAAU,CAACT,GAAD,CAAnC;AACD;AACF;AACF;;AAGDT,EAAAA,eAAe,IAAIpC,0BAAnB;AAEAoC,EAAAA,eAAe,GAAGxC,YAAY,CAACwC,eAAD,EAAkBzB,IAAlB,EAAwBgC,cAAxB,CAA9B;AAEAP,EAAAA,eAAe,IAAIqB,gBAAgB,CAACjB,eAAe,CAAC7B,IAAD,CAAhB,EAAwB+B,cAAxB,CAAnC;AAGAN,EAAAA,eAAe,IAAIV,UAAnB;AAGAU,EAAAA,eAAe,GAAGxC,YAAY,CAACwC,eAAD,EAAkBzB,IAAlB,EAAwBiC,cAAxB,CAA9B;AAEAR,EAAAA,eAAe,GAAGtC,eAAe,CAC/BsC,eAD+B,EAE/BlB,kBAAkB,GAAG,GAAH,GAASM,WAFI,EAG/BH,QAH+B,CAAjC;AAMA,SAAOe,eAAP;AACD;;AAUD,SAASvB,mBAAT,CAA6BL,OAA7B,EAA8D;AAC5D,SAAO,SAASI,WAAT,CAAqB8C,IAArB,EAAqE;AAC1E,UAAMC,QAAQ,GAAG,EAAjB;;AACA,SAAK,MAAM3B,MAAX,IAAqBxB,OAArB,EAA8B;AAG5B,YAAMoD,cAAc,GAAG5B,MAAM,CAACpB,WAAP,CAAmB8C,IAAnB,EAAyBC,QAAzB,CAAvB;AACA1B,MAAAA,MAAM,CAACC,MAAP,CAAcyB,QAAd,EAAwBC,cAAxB;AACD;;AACD,WAAOD,QAAP;AACD,GATD;AAUD;;AAED,SAASrB,aAAT,CAAuB3B,IAAvB,EAA0C;AACxC,yCACoBV,WAAW,CAACU,IAAD,CAAX,CAAkBkD,WAAlB,EADpB;AAGD;;AAOD,SAASxB,mBAAT,CAA6BhC,OAA7B,EAAgG;AAC9F,QAAM;AAACS,IAAAA,EAAD;AAAKJ,IAAAA,MAAL;AAAaC,IAAAA;AAAb,MAAqBN,OAA3B;AACA,QAAMyD,gBAAgB,GAAGhD,EAAE,IAAIJ,MAAM,CAACiB,OAAP,CAAe,aAAf,MAAkC,CAAC,CAAlE;AACA,SAAOmC,gBAAgB,mCAEHhD,EAFG,cAEGb,WAAW,CAACU,IAAD,CAFd,YAKnB,EALJ;AAMD;;AAGD,SAAS4B,qBAAT,CAA+BxB,OAAgB,GAAG,EAAlD,EAA8D;AAC5D,MAAIgD,KAAK,GAAG,CAAZ;AACA,MAAIC,UAAU,GAAG,EAAjB;;AACA,OAAK,MAAMC,MAAX,IAAqBlD,OAArB,EAA8B;AAC5B,QAAIgD,KAAK,KAAK,CAAd,EAAiB;AACfC,MAAAA,UAAU,IAAI,4BAAd;AACD;;AACDD,IAAAA,KAAK;AAEL,UAAMG,KAAK,GAAGnD,OAAO,CAACkD,MAAD,CAArB;;AACA,QAAIC,KAAK,IAAIC,MAAM,CAACC,QAAP,CAAgBF,KAAhB,CAAb,EAAqC;AACnCF,MAAAA,UAAU,sBAAeC,MAAM,CAACJ,WAAP,EAAf,cAAuC9C,OAAO,CAACkD,MAAD,CAA9C,OAAV;AACD;AACF;;AACD,MAAIF,KAAK,KAAK,CAAd,EAAiB;AACfC,IAAAA,UAAU,IAAI,IAAd;AACD;;AACD,SAAOA,UAAP;AACD;;AAED,SAASP,gBAAT,CACEzC,aADF,EAC+C0B,cAD/C,EACoG;AAClG,MAAI2B,MAAM,GAAG,EAAb;;AACA,OAAK,MAAMC,QAAX,IAAuBtD,aAAvB,EAAsC;AACpC,UAAMuD,YAAY,GAAGvD,aAAa,CAACsD,QAAD,CAAlC;AACAD,IAAAA,MAAM,mBAAYE,YAAY,CAACC,SAAzB,SAAN;;AACA,QAAID,YAAY,CAACE,MAAjB,EAAyB;AACvBJ,MAAAA,MAAM,gBAASE,YAAY,CAACE,MAAtB,CAAN;AACD;;AACD,QAAI/B,cAAc,CAAC4B,QAAD,CAAlB,EAA8B;AAC5B,YAAMhB,UAAU,GAAGZ,cAAc,CAAC4B,QAAD,CAAjC;AACAhB,MAAAA,UAAU,CAACoB,IAAX,CAAgB,CAACC,CAAD,EAAqBC,CAArB,KAAoDD,CAAC,CAAC5B,KAAF,GAAU6B,CAAC,CAAC7B,KAAhF;;AACA,WAAK,MAAMD,SAAX,IAAwBQ,UAAxB,EAAoC;AAClCe,QAAAA,MAAM,gBAASvB,SAAS,CAACA,SAAnB,OAAN;AACD;AACF;;AACD,QAAIyB,YAAY,CAACM,MAAjB,EAAyB;AACvBR,MAAAA,MAAM,gBAASE,YAAY,CAACM,MAAtB,CAAN;AACD;;AACDR,IAAAA,MAAM,IAAI,KAAV;AACD;;AAED,SAAOA,MAAP;AACD;;AAED,SAAS5B,sBAAT,CAAgCzB,aAAhC,EAGE;AACA,QAAMqD,MAA0D,GAAG;AACjE/D,IAAAA,EAAE,EAAE,EAD6D;AAEjEC,IAAAA,EAAE,EAAE;AAF6D,GAAnE;AAKAS,EAAAA,aAAa,CAACe,OAAd,CAAuBwC,YAAD,IAAyC;AAC7D,QAAIb,IAAJ;AACA,QAAIoB,IAAJ;;AACA,QAAI,OAAOP,YAAP,KAAwB,QAA5B,EAAsC;AACpCb,MAAAA,IAAI,GAAGa,YAAP;AACAO,MAAAA,IAAI,GAAGpB,IAAI,CAACoB,IAAZ;AACD,KAHD,MAGO;AACLpB,MAAAA,IAAI,GAAG,EAAP;AACAoB,MAAAA,IAAI,GAAGP,YAAP;AACD;;AACDO,IAAAA,IAAI,GAAGA,IAAI,CAACC,IAAL,EAAP;AACA,UAAM,CAACC,KAAD,EAAQR,SAAR,IAAqBM,IAAI,CAACvD,KAAL,CAAW,GAAX,CAA3B;AACA,UAAM2B,IAAI,GAAG4B,IAAI,CAACG,OAAL,CAAa,MAAb,EAAqB,EAArB,CAAb;;AACA,QAAID,KAAK,KAAK,IAAV,IAAkBA,KAAK,KAAK,IAAhC,EAAsC;AACpC,YAAM,IAAIE,KAAJ,CAAUF,KAAV,CAAN;AACD;;AACDX,IAAAA,MAAM,CAACW,KAAD,CAAN,CAAc9B,IAAd,IAAsBjB,MAAM,CAACC,MAAP,CAAcwB,IAAd,EAAoB;AAACc,MAAAA;AAAD,KAApB,CAAtB;AACD,GAjBD;AAmBA,SAAOH,MAAP;AACD","sourcesContent":["import {resolveModules} from './resolve-modules';\nimport {getPlatformShaderDefines, getVersionDefines, PlatformInfo} from './platform-defines';\nimport injectShader, {DECLARATION_INJECT_MARKER} from './inject-shader';\nimport transpileShader from '../transpiler/transpile-shader';\nimport {assert} from '../utils/assert';\nimport {ShaderModuleInstance} from '../shader-module/shader-module-instance';\nimport type { Injection } from '../shader-module/shader-module-instance';\n\n\nconst INJECT_SHADER_DECLARATIONS = `\\n\\n${DECLARATION_INJECT_MARKER}\\n\\n`;\n\nconst SHADER_TYPE = {\n  'fs': 'fragment',\n  'vs': 'vertex'\n};\n\n/**\n * Precision prologue to inject before functions are injected in shader\n * TODO - extract any existing prologue in the fragment source and move it up...\n */\nconst FRAGMENT_SHADER_PROLOGUE = `\\\nprecision highp float;\n\n`;\n\n/** Define map */\ntype Defines = Record<string, string | number | boolean>;\n\nexport type HookFunction = { hook: string; header: string; footer: string; signature?: string};\n\nexport type AssembleShaderOptions = {\n  id?: string;\n  vs: string;\n  fs: string;\n  type?: any;\n  modules?: any[];\n  defines?: Defines;\n  hookFunctions?: (HookFunction | string | { hook: string; header: string; footer: string; })[];\n  inject?: object;\n  transpileToGLSL100?: boolean;\n  prologue?: boolean;\n  log?: any;\n};\n\n/**\n * Inject a list of shader modules into shader sources\n */\nexport function assembleShaders(\n  platformInfo: PlatformInfo,\n  options: AssembleShaderOptions\n): {\n  vs: string;\n  fs: string;\n  getUniforms: any;\n} {\n  const {vs, fs} = options;\n  const modules = resolveModules(options.modules || []);\n  return {\n    vs: assembleShader(platformInfo, {...options, source: vs, type: 'vs', modules}),\n    fs: assembleShader(platformInfo, {...options, source: fs, type: 'fs', modules}),\n    getUniforms: assembleGetUniforms(modules)\n  };\n}\n\n/**\n * Pulls together complete source code for either a vertex or a fragment shader\n * adding prologues, requested module chunks, and any final injections.\n * @param gl \n * @param options \n * @returns \n */\nfunction assembleShader(\n  platformInfo: PlatformInfo,\n  options: {\n    id?: string;\n    source: string;\n    type: 'vs' | 'fs';\n    modules: any[];\n    defines?: Defines;\n    hookFunctions?: any[];\n    inject?: Record<string, any>;\n    transpileToGLSL100?: boolean;\n    prologue?: boolean;\n    log?: any;\n  }\n) {\n  const {\n    id,\n    source,\n    type,\n    modules,\n    defines = {},\n    hookFunctions = [],\n    inject = {},\n    transpileToGLSL100 = false,\n    prologue = true,\n    log\n  } = options;\n\n  assert(typeof source === 'string', 'shader source must be a string');\n\n  const isVertex = type === 'vs';\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 beginning 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${getShaderNameDefine({id, source, type})}\n${getShaderType(type)}\n${getPlatformShaderDefines(platformInfo)}\n${getVersionDefines(platformInfo)}\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: Record<string, Injection[]> = {};\n  const declInjections: Record<string, Injection[]> = {};\n  const mainInjections: Record<string, Injection[]> = {};\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/**\n * Returns a combined `getUniforms` covering the options for all the modules,\n * the created function will pass on options to the inidividual `getUniforms`\n * function of each shader module and combine the results into one object that\n * can be passed to setUniforms.\n * @param modules \n * @returns \n */\nfunction assembleGetUniforms(modules: ShaderModuleInstance[]) {\n  return function getUniforms(opts: Record<string, any>): Record<string, any> {\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: 'fs' | 'vs') {\n  return `\n#define SHADER_TYPE_${SHADER_TYPE[type].toUpperCase()}\n`;\n}\n\n/**\n * Generate \"glslify-compatible\" SHADER_NAME defines\n * These are understood by the GLSL error parsing function\n * If id is provided and no SHADER_NAME constant is present in source, create one\n */\nfunction getShaderNameDefine(options: {id?: string, source: string, type: 'vs' | 'fs'}): string {\n  const {id, source, type} = options;\n  const injectShaderName = id && 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 of key value pairs */\nfunction getApplicationDefines(defines: Defines = {}): string {\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(\n  hookFunctions: Record<string, HookFunction>, hookInjections: Record<string, Injection[]>): string {\n  let result = '';\n  for (const hookName in hookFunctions) {\n    const hookFunction = hookFunctions[hookName];\n    result += `void ${hookFunction.signature} {\\n`;\n    if (hookFunction.header) {\n      result += `  ${hookFunction.header}`;\n    }\n    if (hookInjections[hookName]) {\n      const injections = hookInjections[hookName];\n      injections.sort((a: {order: number}, b: {order: number}): number => a.order - b.order);\n      for (const injection of injections) {\n        result += `  ${injection.injection}\\n`;\n      }\n    }\n    if (hookFunction.footer) {\n      result += `  ${hookFunction.footer}`;\n    }\n    result += '}\\n';\n  }\n\n  return result;\n}\n\nfunction normalizeHookFunctions(hookFunctions: (string | HookFunction)[]): {\n  vs: Record<string, HookFunction>, \n  fs: Record<string, HookFunction>\n} {\n  const result: {vs: Record<string, any>, fs: Record<string, any>} = {\n    vs: {},\n    fs: {}\n  };\n\n  hookFunctions.forEach((hookFunction: string | HookFunction) => {\n    let opts: HookFunction;\n    let hook: string;\n    if (typeof hookFunction !== 'string') {\n      opts = hookFunction;\n      hook = opts.hook;\n    } else {\n      opts = {} as HookFunction;\n      hook = hookFunction;\n    }\n    hook = hook.trim();\n    const [stage, signature] = hook.split(':');\n    const name = hook.replace(/\\(.+/, '');\n    if (stage !== 'vs' && stage !== 'fs') {\n      throw new Error(stage);\n    }\n    result[stage][name] = Object.assign(opts, {signature});\n  });\n\n  return result;\n}\n"],"file":"assemble-shaders.js"}
+{"version":3,"sources":["../../../src/lib/shader-assembler/assemble-shaders.ts"],"names":["glsl","resolveModules","getPlatformShaderDefines","getVersionDefines","injectShader","DECLARATION_INJECT_MARKER","transpileShader","assert","INJECT_SHADER_DECLARATIONS","SHADER_TYPE","FRAGMENT_SHADER_PROLOGUE","assembleShaders","platformInfo","options","vs","fs","modules","assembleShader","source","type","getUniforms","assembleGetUniforms","id","defines","hookFunctions","inject","transpileToGLSL100","prologue","log","isVertex","sourceLines","split","glslVersion","versionLine","coreSource","indexOf","slice","join","allDefines","forEach","module","Object","assign","getDefines","assembledSource","getShaderNameDefine","getShaderType","getApplicationDefines","hookFunctionMap","normalizeHookFunctions","hookInjections","declInjections","mainInjections","key","injection","order","match","hash","name","checkDeprecations","moduleSource","getModuleSource","injections","injectionType","push","getHookFunctions","opts","uniforms","moduleUniforms","toUpperCase","injectShaderName","count","sourceText","define","value","Number","isFinite","result","hookName","hookFunction","signature","header","sort","a","b","footer","hook","trim","stage","replace","Error"],"mappings":"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","sourcesContent":["// luma.gl, MIT license\nimport {glsl} from '../glsl-utils/highlight';\nimport {resolveModules} from './resolve-modules';\nimport {getPlatformShaderDefines, getVersionDefines, PlatformInfo} from './platform-defines';\nimport injectShader, {DECLARATION_INJECT_MARKER} from './inject-shader';\nimport transpileShader from '../transpiler/transpile-shader';\nimport {assert} from '../utils/assert';\nimport {ShaderModuleInstance} from '../shader-module/shader-module-instance';\nimport type { Injection } from '../shader-module/shader-module-instance';\n\n\nconst INJECT_SHADER_DECLARATIONS = `\\n\\n${DECLARATION_INJECT_MARKER}\\n\\n`;\n\nconst SHADER_TYPE = {\n  'fs': 'fragment',\n  'vs': 'vertex'\n};\n\n/**\n * Precision prologue to inject before functions are injected in shader\n * TODO - extract any existing prologue in the fragment source and move it up...\n */\nconst FRAGMENT_SHADER_PROLOGUE = glsl`\\\nprecision highp float;\n\n`;\n\n/** Define map */\ntype Defines = Record<string, string | number | boolean>;\n\nexport type HookFunction = { hook: string; header: string; footer: string; signature?: string};\n\nexport type AssembleShaderOptions = {\n  id?: string;\n  vs: string;\n  fs: string;\n  type?: any;\n  modules?: any[];\n  defines?: Defines;\n  hookFunctions?: (HookFunction | string | { hook: string; header: string; footer: string; })[];\n  inject?: object;\n  transpileToGLSL100?: boolean;\n  prologue?: boolean;\n  log?: any;\n};\n\n/**\n * Inject a list of shader modules into shader sources\n */\nexport function assembleShaders(\n  platformInfo: PlatformInfo,\n  options: AssembleShaderOptions\n): {\n  vs: string;\n  fs: string;\n  getUniforms: any;\n} {\n  const {vs, fs} = options;\n  const modules = resolveModules(options.modules || []);\n  return {\n    vs: assembleShader(platformInfo, {...options, source: vs, type: 'vs', modules}),\n    fs: assembleShader(platformInfo, {...options, source: fs, type: 'fs', modules}),\n    getUniforms: assembleGetUniforms(modules)\n  };\n}\n\n/**\n * Pulls together complete source code for either a vertex or a fragment shader\n * adding prologues, requested module chunks, and any final injections.\n * @param gl \n * @param options \n * @returns \n */\nfunction assembleShader(\n  platformInfo: PlatformInfo,\n  options: {\n    id?: string;\n    source: string;\n    type: 'vs' | 'fs';\n    modules: any[];\n    defines?: Defines;\n    hookFunctions?: any[];\n    inject?: Record<string, any>;\n    transpileToGLSL100?: boolean;\n    prologue?: boolean;\n    log?: any;\n  }\n) {\n  const {\n    id,\n    source,\n    type,\n    modules,\n    defines = {},\n    hookFunctions = [],\n    inject = {},\n    transpileToGLSL100 = false,\n    prologue = true,\n    log\n  } = options;\n\n  assert(typeof source === 'string', 'shader source must be a string');\n\n  const isVertex = type === 'vs';\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 beginning 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${getShaderNameDefine({id, source, type})}\n${getShaderType(type)}\n${getPlatformShaderDefines(platformInfo)}\n${getVersionDefines(platformInfo)}\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: Record<string, Injection[]> = {};\n  const declInjections: Record<string, Injection[]> = {};\n  const mainInjections: Record<string, Injection[]> = {};\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/**\n * Returns a combined `getUniforms` covering the options for all the modules,\n * the created function will pass on options to the inidividual `getUniforms`\n * function of each shader module and combine the results into one object that\n * can be passed to setUniforms.\n * @param modules \n * @returns \n */\nfunction assembleGetUniforms(modules: ShaderModuleInstance[]) {\n  return function getUniforms(opts: Record<string, any>): Record<string, any> {\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: 'fs' | 'vs') {\n  return `\n#define SHADER_TYPE_${SHADER_TYPE[type].toUpperCase()}\n`;\n}\n\n/**\n * Generate \"glslify-compatible\" SHADER_NAME defines\n * These are understood by the GLSL error parsing function\n * If id is provided and no SHADER_NAME constant is present in source, create one\n */\nfunction getShaderNameDefine(options: {id?: string, source: string, type: 'vs' | 'fs'}): string {\n  const {id, source, type} = options;\n  const injectShaderName = id && 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 of key value pairs */\nfunction getApplicationDefines(defines: Defines = {}): string {\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(\n  hookFunctions: Record<string, HookFunction>, hookInjections: Record<string, Injection[]>): string {\n  let result = '';\n  for (const hookName in hookFunctions) {\n    const hookFunction = hookFunctions[hookName];\n    result += `void ${hookFunction.signature} {\\n`;\n    if (hookFunction.header) {\n      result += `  ${hookFunction.header}`;\n    }\n    if (hookInjections[hookName]) {\n      const injections = hookInjections[hookName];\n      injections.sort((a: {order: number}, b: {order: number}): number => a.order - b.order);\n      for (const injection of injections) {\n        result += `  ${injection.injection}\\n`;\n      }\n    }\n    if (hookFunction.footer) {\n      result += `  ${hookFunction.footer}`;\n    }\n    result += '}\\n';\n  }\n\n  return result;\n}\n\nfunction normalizeHookFunctions(hookFunctions: (string | HookFunction)[]): {\n  vs: Record<string, HookFunction>, \n  fs: Record<string, HookFunction>\n} {\n  const result: {vs: Record<string, any>, fs: Record<string, any>} = {\n    vs: {},\n    fs: {}\n  };\n\n  hookFunctions.forEach((hookFunction: string | HookFunction) => {\n    let opts: HookFunction;\n    let hook: string;\n    if (typeof hookFunction !== 'string') {\n      opts = hookFunction;\n      hook = opts.hook;\n    } else {\n      opts = {} as HookFunction;\n      hook = hookFunction;\n    }\n    hook = hook.trim();\n    const [stage, signature] = hook.split(':');\n    const name = hook.replace(/\\(.+/, '');\n    if (stage !== 'vs' && stage !== 'fs') {\n      throw new Error(stage);\n    }\n    result[stage][name] = Object.assign(opts, {signature});\n  });\n\n  return result;\n}\n"],"file":"assemble-shaders.js"}

package/dist/lib/shader-assembler/platform-defines.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"platform-defines.d.ts","sourceRoot":"","sources":["../../../src/lib/shader-assembler/platform-defines.ts"],"names":[],"mappings":"AAAA,oBAAY,YAAY,GAAG;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACvB,CAAC;AAEF,gEAAgE;AAChE,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,CA8C3E;AAED,oEAAoE;AACpE,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,CAiEpE"}
+{"version":3,"file":"platform-defines.d.ts","sourceRoot":"","sources":["../../../src/lib/shader-assembler/platform-defines.ts"],"names":[],"mappings":"AAIA,oBAAY,YAAY,GAAG;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACvB,CAAC;AAEF,gEAAgE;AAChE,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,CA8C3E;AAED,oEAAoE;AACpE,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,CAiEpE"}

package/dist/lib/shader-assembler/platform-defines.js

@@ -1,38 +1,43 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9, _templateObject10;
+
+import { glsl } from '../glsl-utils/highlight';
 export function getPlatformShaderDefines(platformInfo) {
   switch (platformInfo === null || platformInfo === void 0 ? void 0 : platformInfo.gpu.toLowerCase()) {
     case 'apple':
-      return "#define APPLE_GPU\n// Apple optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n";
+      return glsl(_templateObject || (_templateObject = _taggedTemplateLiteral(["#define APPLE_GPU\n// Apple optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n"], ["\\\n#define APPLE_GPU\n// Apple optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n"])));
 
     case 'nvidia':
-      return "#define NVIDIA_GPU\n// Nvidia optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n";
+      return glsl(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["#define NVIDIA_GPU\n// Nvidia optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n"], ["\\\n#define NVIDIA_GPU\n// Nvidia optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n"])));
 
     case 'intel':
-      return "#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";
+      return glsl(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["#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#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"])));
 
     case 'amd':
-      return "#define AMD_GPU\n";
+      return glsl(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["#define AMD_GPU\n"], ["\\\n#define AMD_GPU\n"])));
 
     default:
-      return "#define DEFAULT_GPU\n// Prevent driver from optimizing away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n";
+      return glsl(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["#define DEFAULT_GPU\n// Prevent driver from optimizing away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n"], ["\\\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"])));
   }
 }
 export function getVersionDefines(platformInfo) {
-  let versionDefines = "#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";
+  let versionDefines = glsl(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["#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#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"])));
 
   if (platformInfo.features.has('glsl-frag-depth')) {
-    versionDefines += "\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";
+    versionDefines += glsl(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["\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// 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"])));
   }
 
   if (platformInfo !== null && platformInfo !== void 0 && platformInfo.features.has('glsl-derivatives')) {
-    versionDefines += "\n// DERIVATIVES => dxdF, dxdY and fwidth are available\n#if defined(GL_OES_standard_derivatives) || defined(FEATURE_GLSL_DERIVATIVES)\n#extension GL_OES_standard_derivatives : enable\n# define FEATURE_GLSL_DERIVATIVES\n# define DERIVATIVES\n#endif\n";
+    versionDefines += glsl(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["\n// DERIVATIVES => dxdF, dxdY and fwidth are available\n#if defined(GL_OES_standard_derivatives) || defined(FEATURE_GLSL_DERIVATIVES)\n#extension GL_OES_standard_derivatives : enable\n# define FEATURE_GLSL_DERIVATIVES\n# define DERIVATIVES\n#endif\n"], ["\\\n\n// DERIVATIVES => dxdF, dxdY and fwidth are available\n#if defined(GL_OES_standard_derivatives) || defined(FEATURE_GLSL_DERIVATIVES)\n#extension GL_OES_standard_derivatives : enable\n# define FEATURE_GLSL_DERIVATIVES\n# define DERIVATIVES\n#endif\n"])));
   }
 
   if (platformInfo !== null && platformInfo !== void 0 && platformInfo.features.has('glsl-frag-data')) {
-    versionDefines += "\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";
+    versionDefines += glsl(_templateObject9 || (_templateObject9 = _taggedTemplateLiteral(["\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// 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"])));
   }
 
   if (platformInfo !== null && platformInfo !== void 0 && platformInfo.features.has('glsl-texture-lod')) {
-    versionDefines += "// 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";
+    versionDefines += glsl(_templateObject10 || (_templateObject10 = _taggedTemplateLiteral(["// 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// 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"])));
   }
 
   return versionDefines;

package/dist/lib/shader-assembler/platform-defines.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/shader-assembler/platform-defines.ts"],"names":["getPlatformShaderDefines","platformInfo","gpu","toLowerCase","getVersionDefines","versionDefines","features","has"],"mappings":"AAMA,OAAO,SAASA,wBAAT,CAAkCC,YAAlC,EAAsE;AAC3E,UAAQA,YAAR,aAAQA,YAAR,uBAAQA,YAAY,CAAEC,GAAd,CAAkBC,WAAlB,EAAR;AACE,SAAK,OAAL;AACE;;AASF,SAAK,QAAL;AACE;;AAMF,SAAK,OAAL;AACE;;AAUF,SAAK,KAAL;AAEE;;AAIF;AAIE;AAvCJ;AA6CD;AAGD,OAAO,SAASC,iBAAT,CAA2BH,YAA3B,EAA+D;AACpE,MAAII,cAAc,gUAAlB;;AAiBA,MAAIJ,YAAY,CAACK,QAAb,CAAsBC,GAAtB,CAA0B,iBAA1B,CAAJ,EAAkD;AAChDF,IAAAA,cAAc,2NAAd;AAUD;;AACD,MAAIJ,YAAJ,aAAIA,YAAJ,eAAIA,YAAY,CAAEK,QAAd,CAAuBC,GAAvB,CAA2B,kBAA3B,CAAJ,EAAoD;AAClDF,IAAAA,cAAc,gQAAd;AASD;;AACD,MAAIJ,YAAJ,aAAIA,YAAJ,eAAIA,YAAY,CAAEK,QAAd,CAAuBC,GAAvB,CAA2B,gBAA3B,CAAJ,EAAkD;AAChDF,IAAAA,cAAc,8LAAd;AASD;;AACD,MAAIJ,YAAJ,aAAIA,YAAJ,eAAIA,YAAY,CAAEK,QAAd,CAAuBC,GAAvB,CAA2B,kBAA3B,CAAJ,EAAoD;AAClDF,IAAAA,cAAc,8MAAd;AAUD;;AACD,SAAOA,cAAP;AACD","sourcesContent":["export type PlatformInfo = {\n  gpu: string;\n  features: Set<string>;\n};\n\n/** Adds defines to help identify GPU architecture / platform */\nexport function getPlatformShaderDefines(platformInfo: PlatformInfo): string {\n  switch (platformInfo?.gpu.toLowerCase()) {\n    case 'apple':\n      return `\\\n#define APPLE_GPU\n// Apple optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n`;\n\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`;\n  }\n}\n\n/** Adds defines to let shaders portably v1/v3 check for features */\nexport function getVersionDefines(platformInfo: PlatformInfo): string {\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 (platformInfo.features.has('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 (platformInfo?.features.has('glsl-derivatives')) {\n    versionDefines += `\\\n\n// DERIVATIVES => dxdF, dxdY and fwidth are available\n#if defined(GL_OES_standard_derivatives) || defined(FEATURE_GLSL_DERIVATIVES)\n#extension GL_OES_standard_derivatives : enable\n# define FEATURE_GLSL_DERIVATIVES\n# define DERIVATIVES\n#endif\n`;\n  }\n  if (platformInfo?.features.has('glsl-frag-data')) {\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 (platformInfo?.features.has('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"}
+{"version":3,"sources":["../../../src/lib/shader-assembler/platform-defines.ts"],"names":["glsl","getPlatformShaderDefines","platformInfo","gpu","toLowerCase","getVersionDefines","versionDefines","features","has"],"mappings":";;;;AAEA,SAAQA,IAAR,QAAmB,yBAAnB;AAQA,OAAO,SAASC,wBAAT,CAAkCC,YAAlC,EAAsE;AAC3E,UAAQA,YAAR,aAAQA,YAAR,uBAAQA,YAAY,CAAEC,GAAd,CAAkBC,WAAlB,EAAR;AACE,SAAK,OAAL;AACE,aAAOJ,IAAP;;AASF,SAAK,QAAL;AACE,aAAOA,IAAP;;AAMF,SAAK,OAAL;AACE,aAAOA,IAAP;;AAUF,SAAK,KAAL;AAEE,aAAOA,IAAP;;AAIF;AAIE,aAAOA,IAAP;AAvCJ;AA6CD;AAGD,OAAO,SAASK,iBAAT,CAA2BH,YAA3B,EAA+D;AACpE,MAAII,cAAc,GAAGN,IAAH,usBAAlB;;AAiBA,MAAIE,YAAY,CAACK,QAAb,CAAsBC,GAAtB,CAA0B,iBAA1B,CAAJ,EAAkD;AAChDF,IAAAA,cAAc,IAAIN,IAAJ,2fAAd;AAUD;;AACD,MAAIE,YAAJ,aAAIA,YAAJ,eAAIA,YAAY,CAAEK,QAAd,CAAuBC,GAAvB,CAA2B,kBAA3B,CAAJ,EAAoD;AAClDF,IAAAA,cAAc,IAAIN,IAAJ,qkBAAd;AASD;;AACD,MAAIE,YAAJ,aAAIA,YAAJ,eAAIA,YAAY,CAAEK,QAAd,CAAuBC,GAAvB,CAA2B,gBAA3B,CAAJ,EAAkD;AAChDF,IAAAA,cAAc,IAAIN,IAAJ,icAAd;AASD;;AACD,MAAIE,YAAJ,aAAIA,YAAJ,eAAIA,YAAY,CAAEK,QAAd,CAAuBC,GAAvB,CAA2B,kBAA3B,CAAJ,EAAoD;AAClDF,IAAAA,cAAc,IAAIN,IAAJ,meAAd;AAUD;;AACD,SAAOM,cAAP;AACD","sourcesContent":["// luma.gl, MIT license\n\nimport {glsl} from '../glsl-utils/highlight';\n\nexport type PlatformInfo = {\n  gpu: string;\n  features: Set<string>;\n};\n\n/** Adds defines to help identify GPU architecture / platform */\nexport function getPlatformShaderDefines(platformInfo: PlatformInfo): string {\n  switch (platformInfo?.gpu.toLowerCase()) {\n    case 'apple':\n      return glsl`\\\n#define APPLE_GPU\n// Apple optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n`;\n\n    case 'nvidia':\n      return glsl`\\\n#define NVIDIA_GPU\n// Nvidia optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n`;\n\n    case 'intel':\n      return glsl`\\\n#define INTEL_GPU\n// Intel optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n// Intel's built-in 'tan' function doesn't have acceptable precision\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n`;\n\n    case 'amd':\n      // AMD Does not eliminate fp64 code\n      return glsl`\\\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 glsl`\\\n#define DEFAULT_GPU\n// Prevent driver from optimizing away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n`;\n  }\n}\n\n/** Adds defines to let shaders portably v1/v3 check for features */\nexport function getVersionDefines(platformInfo: PlatformInfo): string {\n  let versionDefines = glsl`\\\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 (platformInfo.features.has('glsl-frag-depth')) {\n    versionDefines += glsl`\\\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 (platformInfo?.features.has('glsl-derivatives')) {\n    versionDefines += glsl`\\\n\n// DERIVATIVES => dxdF, dxdY and fwidth are available\n#if defined(GL_OES_standard_derivatives) || defined(FEATURE_GLSL_DERIVATIVES)\n#extension GL_OES_standard_derivatives : enable\n# define FEATURE_GLSL_DERIVATIVES\n# define DERIVATIVES\n#endif\n`;\n  }\n  if (platformInfo?.features.has('glsl-frag-data')) {\n    versionDefines += glsl`\\\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 (platformInfo?.features.has('glsl-texture-lod')) {\n    versionDefines += glsl`\\\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"}

package/dist/modules/dirlight/dirlight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dirlight.d.ts","sourceRoot":"","sources":["../../../src/modules/dirlight/dirlight.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,aAAa,CAAC;AAG7C,oBAAY,eAAe,GAAG;IAC5B,cAAc,CAAC,EAAE,WAAW,CAAA;CAC7B,CAAA;AAMD,iBAAS,WAAW,CAAC,IAAI,GAAE,eAAwC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAOxF;AAeD;;GAEG;AACF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;CAMrB,CAAC"}
+{"version":3,"file":"dirlight.d.ts","sourceRoot":"","sources":["../../../src/modules/dirlight/dirlight.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,aAAa,CAAC;AAG7C,oBAAY,eAAe,GAAG;IAC5B,cAAc,CAAC,EAAE,WAAW,CAAA;CAC7B,CAAA;AAMD,iBAAS,WAAW,CAAC,IAAI,GAAE,eAAwC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAOxF;AAeD;;GAEG;AACF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;CAMrB,CAAC"}

package/dist/modules/dirlight/dirlight.js

@@ -1,3 +1,8 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+
+var _templateObject;
+
+import { glsl } from '../../lib/glsl-utils/highlight';
 import { project } from '../project/project';
 const DEFAULT_MODULE_OPTIONS = {
   lightDirection: new Float32Array([1, 1, 2])
@@ -13,7 +18,7 @@ function getUniforms(opts = DEFAULT_MODULE_OPTIONS) {
   return uniforms;
 }
 
-var fs = "uniform 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";
+var fs = glsl(_templateObject || (_templateObject = _taggedTemplateLiteral(["uniform 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"], ["\\\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"])));
 export const dirlight = {
   name: 'dirlight',
   fs,

package/dist/modules/dirlight/dirlight.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/modules/dirlight/dirlight.ts"],"names":["project","DEFAULT_MODULE_OPTIONS","lightDirection","Float32Array","getUniforms","opts","uniforms","dirlight_uLightDirection","fs","dirlight","name","dependencies"],"mappings":"AAEA,SAAQA,OAAR,QAAsB,oBAAtB;AAMA,MAAMC,sBAAiD,GAAG;AACxDC,EAAAA,cAAc,EAAE,IAAIC,YAAJ,CAAiB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAjB;AADwC,CAA1D;;AAIA,SAASC,WAAT,CAAqBC,IAAqB,GAAGJ,sBAA7C,EAA0F;AACxF,QAAMK,QAAQ,GAAG,EAAjB;;AACA,MAAID,IAAI,CAACH,cAAT,EAAyB;AAEvBI,IAAAA,QAAQ,CAACC,wBAAT,GAAoCF,IAAI,CAACH,cAAzC;AACD;;AACD,SAAOI,QAAP;AACD;;AAED,IAAIE,EAAE,+TAAN;AAgBC,OAAO,MAAMC,QAAQ,GAAG;AACvBC,EAAAA,IAAI,EAAE,UADiB;AAGvBF,EAAAA,EAHuB;AAIvBJ,EAAAA,WAJuB;AAKvBO,EAAAA,YAAY,EAAE,CAACX,OAAD;AALS,CAAjB","sourcesContent":["// luma.gl, MIT license\nimport type {NumberArray} from '../../types';\nimport {project} from '../project/project';\n\nexport type DirlightOptions = {\n  lightDirection?: NumberArray\n}\n\nconst DEFAULT_MODULE_OPTIONS: Required<DirlightOptions> = {\n  lightDirection: new Float32Array([1, 1, 2])\n};\n\nfunction getUniforms(opts: DirlightOptions = DEFAULT_MODULE_OPTIONS): Record<string, any> {\n  const uniforms = {};\n  if (opts.lightDirection) {\n    // @ts-expect-error TODO add types\n    uniforms.dirlight_uLightDirection = opts.lightDirection;\n  }\n  return uniforms;\n}\n\nvar 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\n/**\n * Cheap lighting - single directional light, single dot product, one uniform\n */\n export const dirlight = {\n  name: 'dirlight',\n  // vs // TODO - reuse normal from geometry module\n  fs,\n  getUniforms,\n  dependencies: [project]\n};\n"],"file":"dirlight.js"}
+{"version":3,"sources":["../../../src/modules/dirlight/dirlight.ts"],"names":["glsl","project","DEFAULT_MODULE_OPTIONS","lightDirection","Float32Array","getUniforms","opts","uniforms","dirlight_uLightDirection","fs","dirlight","name","dependencies"],"mappings":";;;;AACA,SAAQA,IAAR,QAAmB,gCAAnB;AAEA,SAAQC,OAAR,QAAsB,oBAAtB;AAMA,MAAMC,sBAAiD,GAAG;AACxDC,EAAAA,cAAc,EAAE,IAAIC,YAAJ,CAAiB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAjB;AADwC,CAA1D;;AAIA,SAASC,WAAT,CAAqBC,IAAqB,GAAGJ,sBAA7C,EAA0F;AACxF,QAAMK,QAAQ,GAAG,EAAjB;;AACA,MAAID,IAAI,CAACH,cAAT,EAAyB;AAEvBI,IAAAA,QAAQ,CAACC,wBAAT,GAAoCF,IAAI,CAACH,cAAzC;AACD;;AACD,SAAOI,QAAP;AACD;;AAED,IAAIE,EAAE,GAAGT,IAAH,msBAAN;AAgBC,OAAO,MAAMU,QAAQ,GAAG;AACvBC,EAAAA,IAAI,EAAE,UADiB;AAGvBF,EAAAA,EAHuB;AAIvBJ,EAAAA,WAJuB;AAKvBO,EAAAA,YAAY,EAAE,CAACX,OAAD;AALS,CAAjB","sourcesContent":["// luma.gl, MIT license\nimport {glsl} from '../../lib/glsl-utils/highlight';\nimport type {NumberArray} from '../../types';\nimport {project} from '../project/project';\n\nexport type DirlightOptions = {\n  lightDirection?: NumberArray\n}\n\nconst DEFAULT_MODULE_OPTIONS: Required<DirlightOptions> = {\n  lightDirection: new Float32Array([1, 1, 2])\n};\n\nfunction getUniforms(opts: DirlightOptions = DEFAULT_MODULE_OPTIONS): Record<string, any> {\n  const uniforms = {};\n  if (opts.lightDirection) {\n    // @ts-expect-error TODO add types\n    uniforms.dirlight_uLightDirection = opts.lightDirection;\n  }\n  return uniforms;\n}\n\nvar fs = glsl`\\\nuniform vec3 dirlight_uLightDirection;\n\n/*\n * Returns color attenuated by angle from light source\n */\nvec4 dirlight_filterColor(vec4 color) {\n  vec3 normal = project_getNormal_World();\n  float d = abs(dot(normalize(normal), normalize(dirlight_uLightDirection)));\n  return vec4(color.rgb * d, color.a);\n}\n`;\n\n/**\n * Cheap lighting - single directional light, single dot product, one uniform\n */\n export const dirlight = {\n  name: 'dirlight',\n  // vs // TODO - reuse normal from geometry module\n  fs,\n  getUniforms,\n  dependencies: [project]\n};\n"],"file":"dirlight.js"}

package/dist/modules/fp32/fp32.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fp32.d.ts","sourceRoot":"","sources":["../../../src/modules/fp32/fp32.ts"],"names":[],"mappings":"AA2JA;;GAEG;AACH,eAAO,MAAM,IAAI;;;CAGhB,CAAC"}
+{"version":3,"file":"fp32.d.ts","sourceRoot":"","sources":["../../../src/modules/fp32/fp32.ts"],"names":[],"mappings":"AA4JA;;GAEG;AACH,eAAO,MAAM,IAAI;;;CAGhB,CAAC"}

package/dist/modules/fp32/fp32.js

@@ -1,4 +1,9 @@
-const fp32shader = "#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";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+
+var _templateObject;
+
+import { glsl } from '../../lib/glsl-utils/highlight';
+const fp32shader = glsl(_templateObject || (_templateObject = _taggedTemplateLiteral(["#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#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"])));
 export const fp32 = {
   name: 'fp32',
   vs: fp32shader

package/dist/modules/fp32/fp32.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/modules/fp32/fp32.ts"],"names":["fp32shader","fp32","name","vs"],"mappings":"AAEA,MAAMA,UAAU,q0GAAhB;AA4JA,OAAO,MAAMC,IAAI,GAAG;AAClBC,EAAAA,IAAI,EAAE,MADY;AAElBC,EAAAA,EAAE,EAAEH;AAFc,CAAb","sourcesContent":["// import {ShaderModule} from '../../types';\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\n/**\n * 32 bit math library (fixups for GPUs)\n */\nexport const fp32 = {\n  name: 'fp32',\n  vs: fp32shader\n};\n"],"file":"fp32.js"}
+{"version":3,"sources":["../../../src/modules/fp32/fp32.ts"],"names":["glsl","fp32shader","fp32","name","vs"],"mappings":";;;;AAAA,SAAQA,IAAR,QAAmB,gCAAnB;AAGA,MAAMC,UAAU,GAAGD,IAAH,+sNAAhB;AA4JA,OAAO,MAAME,IAAI,GAAG;AAClBC,EAAAA,IAAI,EAAE,MADY;AAElBC,EAAAA,EAAE,EAAEH;AAFc,CAAb","sourcesContent":["import {glsl} from '../../lib/glsl-utils/highlight';\n// import {ShaderModule} from '../../types';\n\nconst fp32shader = glsl`\\\n#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND\n\n// All these functions are for substituting tan() function from Intel GPU only\nconst float TWO_PI = 6.2831854820251465;\nconst float PI_2 = 1.5707963705062866;\nconst float PI_16 = 0.1963495463132858;\n\nconst float SIN_TABLE_0 = 0.19509032368659973;\nconst float SIN_TABLE_1 = 0.3826834261417389;\nconst float SIN_TABLE_2 = 0.5555702447891235;\nconst float SIN_TABLE_3 = 0.7071067690849304;\n\nconst float COS_TABLE_0 = 0.9807852506637573;\nconst float COS_TABLE_1 = 0.9238795042037964;\nconst float COS_TABLE_2 = 0.8314695954322815;\nconst float COS_TABLE_3 = 0.7071067690849304;\n\nconst float INVERSE_FACTORIAL_3 = 1.666666716337204e-01; // 1/3!\nconst float INVERSE_FACTORIAL_5 = 8.333333767950535e-03; // 1/5!\nconst float INVERSE_FACTORIAL_7 = 1.9841270113829523e-04; // 1/7!\nconst float INVERSE_FACTORIAL_9 = 2.75573188446287533e-06; // 1/9!\n\nfloat sin_taylor_fp32(float a) {\n  float r, s, t, x;\n\n  if (a == 0.0) {\n    return 0.0;\n  }\n\n  x = -a * a;\n  s = a;\n  r = a;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_3;\n  s = s + t;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_5;\n  s = s + t;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_7;\n  s = s + t;\n\n  r = r * x;\n  t = r * INVERSE_FACTORIAL_9;\n  s = s + t;\n\n  return s;\n}\n\nvoid sincos_taylor_fp32(float a, out float sin_t, out float cos_t) {\n  if (a == 0.0) {\n    sin_t = 0.0;\n    cos_t = 1.0;\n  }\n  sin_t = sin_taylor_fp32(a);\n  cos_t = sqrt(1.0 - sin_t * sin_t);\n}\n\nfloat tan_taylor_fp32(float a) {\n    float sin_a;\n    float cos_a;\n\n    if (a == 0.0) {\n        return 0.0;\n    }\n\n    // 2pi range reduction\n    float z = floor(a / TWO_PI);\n    float r = a - TWO_PI * z;\n\n    float t;\n    float q = floor(r / PI_2 + 0.5);\n    int j = int(q);\n\n    if (j < -2 || j > 2) {\n        return 1.0 / 0.0;\n    }\n\n    t = r - PI_2 * q;\n\n    q = floor(t / PI_16 + 0.5);\n    int k = int(q);\n    int abs_k = int(abs(float(k)));\n\n    if (abs_k > 4) {\n        return 1.0 / 0.0;\n    } else {\n        t = t - PI_16 * q;\n    }\n\n    float u = 0.0;\n    float v = 0.0;\n\n    float sin_t, cos_t;\n    float s, c;\n    sincos_taylor_fp32(t, sin_t, cos_t);\n\n    if (k == 0) {\n        s = sin_t;\n        c = cos_t;\n    } else {\n        if (abs(float(abs_k) - 1.0) < 0.5) {\n            u = COS_TABLE_0;\n            v = SIN_TABLE_0;\n        } else if (abs(float(abs_k) - 2.0) < 0.5) {\n            u = COS_TABLE_1;\n            v = SIN_TABLE_1;\n        } else if (abs(float(abs_k) - 3.0) < 0.5) {\n            u = COS_TABLE_2;\n            v = SIN_TABLE_2;\n        } else if (abs(float(abs_k) - 4.0) < 0.5) {\n            u = COS_TABLE_3;\n            v = SIN_TABLE_3;\n        }\n        if (k > 0) {\n            s = u * sin_t + v * cos_t;\n            c = u * cos_t - v * sin_t;\n        } else {\n            s = u * sin_t - v * cos_t;\n            c = u * cos_t + v * sin_t;\n        }\n    }\n\n    if (j == 0) {\n        sin_a = s;\n        cos_a = c;\n    } else if (j == 1) {\n        sin_a = c;\n        cos_a = -s;\n    } else if (j == -1) {\n        sin_a = -c;\n        cos_a = s;\n    } else {\n        sin_a = -s;\n        cos_a = -c;\n    }\n    return sin_a / cos_a;\n}\n#endif\n\nfloat tan_fp32(float a) {\n#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND\n  return tan_taylor_fp32(a);\n#else\n  return tan(a);\n#endif\n}\n`;\n\n/**\n * 32 bit math library (fixups for GPUs)\n */\nexport const fp32 = {\n  name: 'fp32',\n  vs: fp32shader\n};\n"],"file":"fp32.js"}

package/dist/modules/fp64/fp64-arithmetic.glsl.d.ts

@@ -1,3 +1,3 @@
-declare const _default: "uniform 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";
+declare const _default: string;
 export default _default;
 //# sourceMappingURL=fp64-arithmetic.glsl.d.ts.map

package/dist/modules/fp64/fp64-arithmetic.glsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fp64-arithmetic.glsl.d.ts","sourceRoot":"","sources":["../../../src/modules/fp64/fp64-arithmetic.glsl.ts"],"names":[],"mappings":";AAEA,wBAsKE"}
+{"version":3,"file":"fp64-arithmetic.glsl.d.ts","sourceRoot":"","sources":["../../../src/modules/fp64/fp64-arithmetic.glsl.ts"],"names":[],"mappings":";AAGA,wBAsKE"}

package/dist/modules/fp64/fp64-arithmetic.glsl.js

@@ -1,2 +1,7 @@
-export default "uniform 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";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+
+var _templateObject;
+
+import { glsl } from '../../lib/glsl-utils/highlight';
+export default glsl(_templateObject || (_templateObject = _taggedTemplateLiteral(["uniform 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"], ["\\\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"])));
 //# sourceMappingURL=fp64-arithmetic.glsl.js.map

package/dist/modules/fp64/fp64-arithmetic.glsl.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/modules/fp64/fp64-arithmetic.glsl.ts"],"names":[],"mappings":"AAEA","sourcesContent":["// luma.gl, MIT license\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"],"file":"fp64-arithmetic.glsl.js"}
+{"version":3,"sources":["../../../src/modules/fp64/fp64-arithmetic.glsl.ts"],"names":["glsl"],"mappings":";;;;AACA,SAAQA,IAAR,QAAmB,gCAAnB;AAEA,eAAeA,IAAf","sourcesContent":["// luma.gl, MIT license\nimport {glsl} from '../../lib/glsl-utils/highlight';\n\nexport default glsl`\\\nuniform float ONE;\n\n/*\nAbout LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n\nThe purpose of this workaround is to prevent shader compilers from\noptimizing away necessary arithmetic operations by swapping their sequences\nor transform the equation to some 'equivalent' 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"],"file":"fp64-arithmetic.glsl.js"}