@ohuoy/easymap 1.0.0 → 1.0.2

package/lib/@antv/l7-core/es/services/scene/SceneService.js

@@ -0,0 +1,340 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+// @ts-ignore
+import { AsyncSeriesHook } from '../../../../async-hook';
+import { DOM } from '../../../../l7-utils';
+import elementResizeDetectorMaker from 'element-resize-detector';
+import { EventEmitter } from 'eventemitter3';
+import { createRendererContainer } from "../../utils/dom";
+import { InteractionEvent } from "../interaction/IInteractionService";
+/**
+ * will emit `loaded` `resize` `destroy` event panstart panmove panend
+ */
+export default class Scene extends EventEmitter {
+  /**
+   * 使用各种 Service
+   */
+  get iconService() {
+    return this.container.iconService;
+  }
+  get fontService() {
+    return this.container.fontService;
+  }
+  get controlService() {
+    return this.container.controlService;
+  }
+  get configService() {
+    return this.container.globalConfigService;
+  }
+  get map() {
+    return this.container.mapService;
+  }
+  get coordinateSystemService() {
+    return this.container.coordinateSystemService;
+  }
+  get rendererService() {
+    return this.container.rendererService;
+  }
+  get layerService() {
+    return this.container.layerService;
+  }
+  get debugService() {
+    return this.container.debugService;
+  }
+  get cameraService() {
+    return this.container.cameraService;
+  }
+  get interactionService() {
+    return this.container.interactionService;
+  }
+  get pickingService() {
+    return this.container.pickingService;
+  }
+  get shaderModuleService() {
+    return this.container.shaderModuleService;
+  }
+  get markerService() {
+    return this.container.markerService;
+  }
+  get popupService() {
+    return this.container.popupService;
+  }
+
+  /**
+   * 是否首次渲染
+   */
+
+  constructor(container) {
+    super();
+    // @see https://github.com/webpack/tapable#usage
+    _defineProperty(this, "destroyed", false);
+    _defineProperty(this, "loaded", false);
+    _defineProperty(this, "id", void 0);
+    _defineProperty(this, "inited", false);
+    // TODO: 改成状态机
+    _defineProperty(this, "rendering", false);
+    /**
+     * canvas 容器
+     */
+    _defineProperty(this, "$container", void 0);
+    _defineProperty(this, "canvas", void 0);
+    _defineProperty(this, "markerContainer", void 0);
+    _defineProperty(this, "resizeDetector", void 0);
+    _defineProperty(this, "hooks", void 0);
+    _defineProperty(this, "handleWindowResized", () => {
+      this.emit('resize');
+      // @ts-check
+      if (this.$container) {
+        this.initContainer();
+        // 触发 Map， canvas
+        // DOM.triggerResize();
+        this.coordinateSystemService.needRefresh = true;
+        //  repaint layers
+        this.render();
+      }
+    });
+    _defineProperty(this, "handleMapCameraChanged", viewport => {
+      this.cameraService.update(viewport);
+      this.render();
+    });
+    this.container = container;
+    this.hooks = {
+      /**
+       * 初始化异步任务，可并行：
+       * 1. initMap：初始化地图底图、相机
+       * 2. initRenderer：初始化渲染引擎
+       * 3. initWorker：初始化 Worker
+       */
+      init: new AsyncSeriesHook()
+    };
+    this.id = container.id;
+  }
+  init(sceneConfig) {
+    var _this = this;
+    // 设置场景配置项
+    this.configService.setSceneConfig(this.id, sceneConfig);
+    // 初始化 ShaderModule
+    this.shaderModuleService.registerBuiltinModules();
+
+    // 初始化资源管理 图片
+    this.iconService.init();
+    this.iconService.on('imageUpdate', () => this.render());
+    // 字体资源
+    this.fontService.init();
+    /**
+     * 初始化底图
+     */
+    this.hooks.init.tapPromise('initMap', /*#__PURE__*/_asyncToGenerator(function* () {
+      _this.debugService.log('map.mapInitStart', {
+        type: _this.map.version
+      });
+      // 等待首次相机同步
+      yield new Promise(resolve => {
+        _this.map.onCameraChanged(viewport => {
+          _this.cameraService.init();
+          _this.cameraService.update(viewport);
+          resolve();
+        });
+        _this.map.init();
+      });
+
+      // 重新绑定非首次相机更新事件
+      _this.map.onCameraChanged(_this.handleMapCameraChanged);
+      _this.map.addMarkerContainer();
+      // 初始化未加载的marker;
+      _this.markerService.addMarkers();
+      _this.markerService.addMarkerLayers();
+      _this.popupService.initPopup();
+      // 地图初始化之后 才能初始化 container 上的交互
+      _this.interactionService.init();
+      _this.interactionService.on(InteractionEvent.Drag, _this.addSceneEvent.bind(_this));
+    }));
+
+    /**
+     * 初始化渲染引擎
+     */
+    this.hooks.init.tapPromise('initRenderer', /*#__PURE__*/_asyncToGenerator(function* () {
+      var _this$map;
+      // https://github.com/antvis/L7/issues/1459#issuecomment-1709481920 不确定我什么会报错先兼容一下
+      const renderContainer = ((_this$map = _this.map) === null || _this$map === void 0 ? void 0 : _this$map.getOverlayContainer()) || undefined;
+      if (renderContainer) {
+        _this.$container = renderContainer;
+      } else {
+        _this.$container = createRendererContainer(_this.configService.getSceneConfig(_this.id).id || '');
+      }
+
+      // 创建底图之上的 container
+      if (_this.$container) {
+        _this.canvas = DOM.create('canvas', '', _this.$container);
+        _this.setCanvas();
+        yield _this.rendererService.init(
+        // @ts-ignore
+        _this.canvas, _this.configService.getSceneConfig(_this.id), sceneConfig.gl);
+        _this.registerContextLost();
+        _this.initContainer();
+        _this.resizeDetector = elementResizeDetectorMaker({
+          strategy: 'scroll' //<- For ultra performance.
+        });
+        _this.resizeDetector.listenTo(_this.$container, _this.handleWindowResized);
+        if (window.matchMedia) {
+          var _window$matchMedia;
+          (_window$matchMedia = window.matchMedia('screen and (-webkit-min-device-pixel-ratio: 1.5)')) === null || _window$matchMedia === void 0 || _window$matchMedia.addListener(_this.handleWindowResized.bind('screen'));
+        }
+      } else {
+        console.error('容器 id 不存在');
+      }
+      _this.pickingService.init(_this.id);
+    }));
+    this.render();
+  }
+  registerContextLost() {
+    const canvas = this.rendererService.getCanvas();
+    if (canvas) {
+      canvas.addEventListener('webglcontextlost', () => this.emit('webglcontextlost'));
+    }
+  }
+  addLayer(layer) {
+    this.layerService.sceneService = this;
+    this.layerService.add(layer);
+  }
+  addMask(mask) {
+    this.layerService.sceneService = this;
+    this.layerService.addMask(mask);
+  }
+  render() {
+    var _this2 = this;
+    return _asyncToGenerator(function* () {
+      if (_this2.rendering || _this2.destroyed) {
+        return;
+      }
+      _this2.rendering = true;
+      // 首次初始化，或者地图的容器被强制销毁的需要重新初始化
+      if (!_this2.inited) {
+        // 还未初始化完成需要等待
+
+        yield _this2.hooks.init.promise(); // 初始化地图和渲染
+        if (_this2.destroyed) {
+          _this2.destroy();
+        }
+        // FIXME: 初始化 marker 容器，可以放到 map 初始化方法中？
+        yield _this2.layerService.initLayers();
+        _this2.layerService.renderLayers();
+        _this2.controlService.addControls();
+        _this2.loaded = true;
+        _this2.emit('loaded');
+        _this2.inited = true;
+      } else {
+        // 尝试初始化未初始化的图层
+        yield _this2.layerService.initLayers();
+        yield _this2.layerService.renderLayers();
+      }
+
+      // 组件需要等待layer 初始化完成之后添加
+      _this2.rendering = false;
+    })();
+  }
+
+  /**
+   * 用户自定义添加第三方字体 （用户使用 layer/point/text/iconfont 的前提需要加载第三方字体文件）
+   * @param fontFamily
+   * @param fontPath
+   */
+  addFontFace(fontFamily, fontPath) {
+    this.fontService.addFontFace(fontFamily, fontPath);
+  }
+  getSceneContainer() {
+    return this.$container;
+  }
+  exportPng(type) {
+    var _this3 = this;
+    return _asyncToGenerator(function* () {
+      var _this3$$container;
+      const renderCanvas = (_this3$$container = _this3.$container) === null || _this3$$container === void 0 ? void 0 : _this3$$container.getElementsByTagName('canvas')[0];
+      yield _this3.render();
+      const layersPng = type === 'jpg' ? renderCanvas === null || renderCanvas === void 0 ? void 0 : renderCanvas.toDataURL('image/jpeg') : renderCanvas === null || renderCanvas === void 0 ? void 0 : renderCanvas.toDataURL('image/png');
+      return layersPng;
+    })();
+  }
+  getSceneConfig() {
+    return this.configService.getSceneConfig(this.id);
+  }
+
+  // get point size info
+  getPointSizeRange() {
+    return this.rendererService.getPointSizeRange();
+  }
+  addMarkerContainer() {
+    // @ts-ignore
+    const mapContainer = this.$container.parentElement;
+    if (mapContainer !== null) {
+      this.markerContainer = DOM.create('div', 'l7-marker-container', mapContainer);
+    }
+  }
+  getMarkerContainer() {
+    return this.markerContainer;
+  }
+  destroy() {
+    var _this$$container2;
+    if (!this.inited) {
+      this.destroyed = true;
+      return;
+    }
+    this.resizeDetector.removeListener(this.$container, this.handleWindowResized);
+    this.pickingService.destroy();
+    this.layerService.destroy();
+
+    // this.rendererService.destroy();
+
+    this.interactionService.destroy();
+    this.controlService.destroy();
+    this.markerService.destroy();
+    this.fontService.destroy();
+    this.iconService.destroy();
+    this.removeAllListeners();
+    this.inited = false;
+    this.map.destroy();
+    setTimeout(() => {
+      var _this$$container;
+      (_this$$container = this.$container) === null || _this$$container === void 0 || _this$$container.removeChild(this.canvas);
+      // this.canvas = null 清除对 webgl 实例的引用
+      // @ts-ignore
+      this.canvas = null;
+      // Tip: 把这一部分销毁放到写下一个事件循环中执行，兼容 L7React 中 scene 和 layer 同时销毁的情况
+      this.rendererService.destroy();
+    });
+    // 销毁 container 容器
+    (_this$$container2 = this.$container) === null || _this$$container2 === void 0 || (_this$$container2 = _this$$container2.parentNode) === null || _this$$container2 === void 0 || _this$$container2.removeChild(this.$container);
+    this.emit('destroy');
+  }
+  initContainer() {
+    var _this$$container3, _this$$container4;
+    const pixelRatio = DOM.DPR;
+    const w = ((_this$$container3 = this.$container) === null || _this$$container3 === void 0 ? void 0 : _this$$container3.clientWidth) || 400;
+    const h = ((_this$$container4 = this.$container) === null || _this$$container4 === void 0 ? void 0 : _this$$container4.clientHeight) || 300;
+    const canvas = this.canvas;
+    if (canvas) {
+      canvas.width = w * pixelRatio;
+      canvas.height = h * pixelRatio;
+    }
+    this.rendererService.viewport({
+      x: 0,
+      y: 0,
+      width: pixelRatio * w,
+      height: pixelRatio * h
+    });
+  }
+  setCanvas() {
+    var _this$$container5, _this$$container6;
+    const pixelRatio = DOM.DPR;
+    const w = ((_this$$container5 = this.$container) === null || _this$$container5 === void 0 ? void 0 : _this$$container5.clientWidth) || 400;
+    const h = ((_this$$container6 = this.$container) === null || _this$$container6 === void 0 ? void 0 : _this$$container6.clientHeight) || 300;
+    const canvas = this.canvas;
+    canvas.width = w * pixelRatio;
+    canvas.height = h * pixelRatio;
+    canvas.style.width = '100%';
+    canvas.style.height = '100%';
+  }
+  addSceneEvent(target) {
+    this.emit(target.type, target);
+  }
+}

package/lib/@antv/l7-core/es/services/shader/IShaderModuleService.d.ts

@@ -0,0 +1,22 @@
+import type { IInject } from '../renderer/IModel';
+import type { IUniform } from '../renderer/IUniform';
+/**
+ * 提供 ShaderModule 管理服务
+ */
+export interface IModuleParams {
+    vs: string;
+    fs: string;
+    uniforms?: {
+        [key: string]: IUniform;
+    };
+    inject?: IInject;
+}
+export interface IShaderModuleService {
+    registerModule(moduleName: string, moduleParams: IModuleParams): void;
+    getModule(moduleName: string): IModuleParams;
+    /**
+     * 注册 L7 内置 shader module
+     */
+    registerBuiltinModules(): void;
+    destroy(): void;
+}

package/lib/@antv/l7-core/es/services/shader/IShaderModuleService.js

@@ -0,0 +1 @@
+export {};

package/lib/@antv/l7-core/es/services/shader/ShaderModuleService.d.ts

@@ -0,0 +1,11 @@
+import type { IModuleParams, IShaderModuleService } from './IShaderModuleService';
+export default class ShaderModuleService implements IShaderModuleService {
+    private moduleCache;
+    private rawContentCache;
+    registerBuiltinModules(): void;
+    registerModule(moduleName: string, moduleParams: IModuleParams): void;
+    destroy(): void;
+    getModule(moduleName: string): IModuleParams;
+    private processModule;
+    private injectDefines;
+}

package/lib/@antv/l7-core/es/services/shader/ShaderModuleService.js

@@ -0,0 +1,206 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { lodashUtil } from '../../../../l7-utils';
+import { extractUniforms } from "../../utils/shader-module";
+const {
+  uniq
+} = lodashUtil;
+/* babel-plugin-inline-import '../../shaders/common.glsl' */
+const common = "#define PI 3.14159265359";
+/* babel-plugin-inline-import '../../shaders/common_light.glsl' */
+const light = "#define ambientRatio 0.5\n#define diffuseRatio 0.3\n#define specularRatio 0.2\n\n\nfloat calc_lighting(vec4 pos) {\n\n    vec3 worldPos = vec3(pos * u_ModelMatrix);\n\n    vec3 worldNormal = a_Normal;\n      // //cal light weight\n    vec3 viewDir = normalize(u_CameraPosition - worldPos);\n\n    vec3 lightDir = normalize(vec3(1, -10.5, 12));\n\n    vec3 halfDir = normalize(viewDir+lightDir);\n      // //lambert\n    float lambert = dot(worldNormal, lightDir);\n        //specular\n    float specular = pow(max(0.0, dot(worldNormal, halfDir)), 32.0);\n        //sum to light weight\n    float lightWeight = ambientRatio + diffuseRatio * lambert + specularRatio * specular;\n\n    return lightWeight;\n}\n";
+/* babel-plugin-inline-import '../../shaders/decode.glsl' */
+const decode = "#define SHIFT_RIGHT17 1.0 / 131072.0\n#define SHIFT_RIGHT18 1.0 / 262144.0\n#define SHIFT_RIGHT19 1.0 / 524288.0\n#define SHIFT_RIGHT20 1.0 / 1048576.0\n#define SHIFT_RIGHT21 1.0 / 2097152.0\n#define SHIFT_RIGHT22 1.0 / 4194304.0\n#define SHIFT_RIGHT23 1.0 / 8388608.0\n#define SHIFT_RIGHT24 1.0 / 16777216.0\n\n#define SHIFT_LEFT17 131072.0\n#define SHIFT_LEFT18 262144.0\n#define SHIFT_LEFT19 524288.0\n#define SHIFT_LEFT20 1048576.0\n#define SHIFT_LEFT21 2097152.0\n#define SHIFT_LEFT22 4194304.0\n#define SHIFT_LEFT23 8388608.0\n#define SHIFT_LEFT24 16777216.0\n\nvec2 unpack_float(float packedValue) {\n  int packedIntValue = int(packedValue);\n  int v0 = packedIntValue / 256;\n  return vec2(v0, packedIntValue - v0 * 256);\n}\n\nvec4 decode_color(vec2 encodedColor) {\n  return vec4(\n    unpack_float(encodedColor[0]) / 255.0,\n    unpack_float(encodedColor[1]) / 255.0\n  );\n}\n";
+/* babel-plugin-inline-import '../../shaders/lighting.glsl' */
+const lighting = "// Blinn-Phong model\n// apply lighting in vertex shader instead of fragment shader\n// @see https://learnopengl.com/Advanced-Lighting/Advanced-Lighting\nuniform float u_Ambient : 1.0;\nuniform float u_Diffuse : 1.0;\nuniform float u_Specular : 1.0;\nuniform int u_NumOfDirectionalLights : 1;\nuniform int u_NumOfSpotLights : 0;\n\n#define SHININESS 32.0\n#define MAX_NUM_OF_DIRECTIONAL_LIGHTS 3\n#define MAX_NUM_OF_SPOT_LIGHTS 3\n\nstruct DirectionalLight {\n  vec3 direction;\n  vec3 ambient;\n  vec3 diffuse;\n  vec3 specular;\n};\n\nstruct SpotLight {\n  vec3 position;\n  vec3 direction;\n  vec3 ambient;\n  vec3 diffuse;\n  vec3 specular;\n  float constant;\n  float linear;\n  float quadratic;\n  float angle;\n  float blur;\n  float exponent;\n};\n\nuniform DirectionalLight u_DirectionalLights[MAX_NUM_OF_DIRECTIONAL_LIGHTS];\nuniform SpotLight u_SpotLights[MAX_NUM_OF_SPOT_LIGHTS];\n\nvec3 calc_directional_light(DirectionalLight light, vec3 normal, vec3 viewDir) {\n  vec3 lightDir = normalize(light.direction);\n  // diffuse shading\n  float diff = max(dot(normal, lightDir), 0.0);\n  // Blinn-Phong specular shading\n  vec3 halfwayDir = normalize(lightDir + viewDir);\n  float spec = pow(max(dot(normal, halfwayDir), 0.0), SHININESS);\n\n  vec3 ambient = light.ambient * u_Ambient;\n  vec3 diffuse = light.diffuse * diff * u_Diffuse;\n  vec3 specular = light.specular * spec * u_Specular;\n\n  return ambient + diffuse + specular;\n}\n\n\nvec3 calc_lighting(vec3 position, vec3 normal, vec3 viewDir) {\n  vec3 weight = vec3(0.0);\n  for (int i = 0; i < MAX_NUM_OF_DIRECTIONAL_LIGHTS; i++) {\n    if (i >= u_NumOfDirectionalLights) {\n      break;\n    }\n    weight += calc_directional_light(u_DirectionalLights[i], normal, viewDir);\n  }\n  return weight;\n}\n";
+/* babel-plugin-inline-import '../../shaders/picking.frag.glsl' */
+const pickingFrag = "\nin vec4 v_PickingResult;\n\n#pragma include \"picking_uniforms\"\n\n#define PICKING_NONE 0.0\n#define PICKING_ENCODE 1.0\n#define PICKING_HIGHLIGHT 2.0\n#define COLOR_SCALE 1. / 255.\n\n#define HIGHLIGHT 1.0\n#define SELECT 2.0\n\n/*\n * Returns highlight color if this item is selected.\n */\nvec4 filterHighlightColor(vec4 color, float weight) {\n  float activeType = v_PickingResult.a;\n  if(activeType > 0.0) {\n    vec4 highLightColor =  activeType > 1.5 ? u_SelectColor : u_HighlightColor;\n    highLightColor = highLightColor * COLOR_SCALE;\n    float highLightAlpha = highLightColor.a;\n    float highLightRatio = highLightAlpha / (highLightAlpha + color.a * (1.0 - highLightAlpha));\n    vec3 resultRGB = mix(color.rgb, highLightColor.rgb, highLightRatio);\n    return vec4(mix(resultRGB * weight, color.rgb, u_activeMix), color.a);\n  }\n  else {\n    return color;\n  }\n\n  \n}\n\n/*\n * Returns picking color if picking enabled else unmodified argument.\n */\nvec4 filterPickingColor(vec4 color) {\n  vec3 pickingColor = v_PickingResult.rgb;\n  if (u_PickingStage == PICKING_ENCODE && length(pickingColor) < 0.001) {\n    discard;\n  }\n  return u_PickingStage == PICKING_ENCODE ? vec4(pickingColor, step(0.001,color.a)): color;\n}\n\n/*\n * Returns picking color if picking is enabled if not\n * highlight color if this item is selected, otherwise unmodified argument.\n */\nvec4 filterColor(vec4 color) {\n  // \u8FC7\u6EE4\u591A\u4F59\u7684 shader \u8BA1\u7B97\n  // return color;\n  if(u_shaderPick < 0.5) {\n    return color; // \u6682\u65F6\u53BB\u9664 \u76F4\u63A5\u53D6\u6D88\u8BA1\u7B97\u5728\u9009\u4E2D\u65F6\u62D6\u62FD\u5730\u56FE\u4F1A\u6709\u95EE\u9898\n  } else {\n    return filterPickingColor(filterHighlightColor(color, 1.0));\n  }\n  \n}\n\nvec4 filterColorAlpha(vec4 color, float alpha) {\n  // \u8FC7\u6EE4\u591A\u4F59\u7684 shader \u8BA1\u7B97\n  // return color;\n  if(u_shaderPick < 0.5) {\n    return color; // \u6682\u65F6\u53BB\u9664 \u76F4\u63A5\u53D6\u6D88\u8BA1\u7B97\u5728\u9009\u4E2D\u65F6\u62D6\u62FD\u5730\u56FE\u4F1A\u6709\u95EE\u9898\n  } else {\n    return filterPickingColor(filterHighlightColor(color, alpha));\n  }\n}\n\n";
+/* babel-plugin-inline-import '../../shaders/picking.vert.glsl' */
+const pickingVert = "layout(location = 3) in vec3 a_PickingColor;\nout vec4 v_PickingResult;\n\n#pragma include \"picking_uniforms\"\n\n#define PICKING_NONE 0.0\n#define PICKING_ENCODE 1.0\n#define PICKING_HIGHLIGHT 2.0\n#define COLOR_SCALE 1. / 255.\n\n#define NORMAL 0.0\n#define HIGHLIGHT 1.0\n#define SELECT 2.0\n\nbool isVertexPicked(vec3 vertexColor) {\n  return distance(vertexColor,u_PickingColor.rgb) < 0.01;\n}\n\n// \u5224\u65AD\u5F53\u524D\u70B9\u662F\u5426\u5DF2\u7ECF\u88AB select \u9009\u4E2D\nbool isVertexSelected(vec3 vertexColor) {\n  return distance(vertexColor,u_CurrentSelectedId.rgb) < 0.01;\n}\n\nvoid setPickingColor(vec3 pickingColor) {\n  if(u_shaderPick < 0.5) {\n    return;\n  }\n  // compares only in highlight stage\n\n  if(u_PickingStage == PICKING_HIGHLIGHT) {\n    if(isVertexPicked(pickingColor)) {\n       v_PickingResult = vec4(pickingColor.rgb * COLOR_SCALE,HIGHLIGHT);\n       return;\n    }\n    if(isVertexSelected(pickingColor)) {\n     v_PickingResult = vec4(u_CurrentSelectedId.rgb * COLOR_SCALE,SELECT);\n      return;\n    }\n\n  } else {\n      v_PickingResult= vec4(pickingColor.rgb * COLOR_SCALE,NORMAL);\n      return;\n  }\n\n  // // v_PickingResult.a = float((u_PickingStage == PICKING_HIGHLIGHT) && (isVertexPicked(pickingColor) || isVertexPicked(u_CurrentSelectedId)));\n\n  // // Stores the picking color so that the fragment shader can render it during picking\n  // v_PickingResult.rgb = pickingColor * COLOR_SCALE;\n}\n\nfloat setPickingSize(float x) {\n   return u_PickingStage == PICKING_ENCODE ? x + u_PickingBuffer : x;\n}\n\nfloat setPickingOrder(float z) {\n   bool selected = bool(v_PickingResult.a);\n   return selected ? z + 1. : 0.;\n}\n";
+/* babel-plugin-inline-import '../../shaders/picking_uniforms.glsl' */
+const picking_uniforms = "layout(std140) uniform PickingUniforms {\n  vec4 u_HighlightColor;\n  vec4 u_SelectColor;\n  vec3 u_PickingColor;\n  float u_PickingStage;\n  vec3 u_CurrentSelectedId;\n  float u_PickingThreshold;\n  float u_PickingBuffer;\n  float u_shaderPick;\n  float u_activeMix;\n};";
+/* babel-plugin-inline-import '../../shaders/project.glsl' */
+const project = "\n#define E 2.718281828459045\nvec2 ProjectFlat(vec2 lnglat){\n  float maxs=85.0511287798;\n  float lat=max(min(maxs,lnglat.y),-maxs);\n  float scale= 268435456.;\n  float d=PI/180.;\n  float x=lnglat.x*d;\n  float y=lat*d;\n  y=log(tan((PI/4.)+(y/2.)));\n\n  float a=.5/PI,\n  b=.5,\n  c=-.5/PI;\n  d=.5;\n  x=scale*(a*x+b);\n  y=scale*(c*y+d);\n  return vec2(x,y);\n}\n\nvec2 unProjectFlat(vec2 px){\n  float a=.5/PI;\n  float b=.5;\n  float c=-.5/PI;\n  float d=.5;\n  float scale = 268435456.;\n  float x=(px.x/scale-b)/a;\n  float y=(px.y/scale-d)/c;\n  y=(atan(pow(E,y))-(PI/4.))*2.;\n  d=PI/180.;\n  float lat=y/d;\n  float lng=x/d;\n  return vec2(lng,lat);\n}\n\nfloat pixelDistance(vec2 from, vec2 to) {\n vec2 a1 = ProjectFlat(from);\n vec2 b1 = ProjectFlat(to);\n return distance(a1, b1);\n}\n\n// gaode2.0\nvec2 customProject(vec2 lnglat) { // \u7ECF\u7EAC\u5EA6 => \u5E73\u9762\u5750\u6807\n  float t = lnglat.x;\n  float e = lnglat.y;\n  float Sm = 180.0 / PI;\n  float Tm = 6378137.0;\n  float Rm = PI / 180.0;\n  float r = 85.0511287798;\n  e = max(min(r, e), -r);\n  t *= Rm;\n  e *= Rm;\n  e = log(tan(PI / 4.0 + e / 2.0));\n  return vec2(t * Tm, e * Tm);\n}\n\nvec2 unProjCustomCoord(vec2 point) { // \u5E73\u9762\u5750\u6807 => \u7ECF\u7EAC\u5EA6\n  float Sm = 57.29577951308232; //180 / Math.PI\n  float Tm = 6378137.0;\n  float t = point.x;\n  float e = point.y;\n  return vec2(t / Tm * Sm, (2.0 * atan(exp(e / Tm)) - PI / 2.0) * Sm);\n}\n\n\nfloat customPixelDistance(vec2 from, vec2 to) {\n vec2 a1 = ProjectFlat(from);\n vec2 b1 = ProjectFlat(to);\n return distance(a1, b1);\n}";
+/* babel-plugin-inline-import '../../shaders/projection.glsl' */
+const projection = "#define TILE_SIZE 512.0\n#define PI 3.1415926536\n#define WORLD_SCALE TILE_SIZE / (PI * 2.0)\n#define EARTH_CIRCUMFERENCE 40.03e6\n\n#define COORDINATE_SYSTEM_LNGLAT 1.0        // mapbox\n#define COORDINATE_SYSTEM_LNGLAT_OFFSET 2.0 // mapbox offset\n#define COORDINATE_SYSTEM_VECTOR_TILE 3.0\n#define COORDINATE_SYSTEM_IDENTITY 4.0\n#define COORDINATE_SYSTEM_P20 5.0           // amap\n#define COORDINATE_SYSTEM_P20_OFFSET 6.0    // amap offset\n#define COORDINATE_SYSTEM_METER_OFFSET 7.0\n\n#define COORDINATE_SYSTEM_P20_2 8.0         // amap2.0\n#pragma include \"scene_uniforms\"\n\n\n// web mercator coords -> world coords\nvec2 project_mercator(vec2 lnglat) {\n   if (u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.0\n    return lnglat;\n  }\n  float x = lnglat.x;\n  return vec2(\n    radians(x) + PI,\n    PI - log(tan(PI * 0.25 + radians(lnglat.y) * 0.5))\n  );\n}\n\nfloat project_scale(float meters) {\n  return meters * u_PixelsPerMeter.z;\n}\n\n\n// offset coords -> world coords\nvec4 project_offset(vec4 offset) {\n  float dy = offset.y;\n  dy = clamp(dy, -1., 1.);\n  vec3 pixels_per_unit = u_PixelsPerDegree + u_PixelsPerDegree2 * dy;\n  return vec4(offset.xyz * pixels_per_unit, offset.w);\n}\n\nvec3 project_normal(vec3 normal) {\n  vec4 normal_modelspace = u_ModelMatrix * vec4(normal, 0.0);\n  return normalize(normal_modelspace.xyz * u_PixelsPerMeter);\n}\n\nvec3 project_offset_normal(vec3 vector) {\n  if (u_CoordinateSystem < COORDINATE_SYSTEM_LNGLAT + 0.01 && u_CoordinateSystem >COORDINATE_SYSTEM_LNGLAT - 0.01\n    || u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET) {\n    // normals generated by the polygon tesselator are in lnglat offsets instead of meters\n    return normalize(vector * u_PixelsPerDegree);\n  }\n  return project_normal(vector);\n}\n// || u_CoordinateSystem < COORDINATE_SYSTEM_P20_OFFSET + 0.01 && u_CoordinateSystem >COORDINATE_SYSTEM_P20_OFFSET - 0.01\n// reverse Y\nvec3 reverse_offset_normal(vec3 vector) {\n  if (u_CoordinateSystem == COORDINATE_SYSTEM_P20 ||u_CoordinateSystem == COORDINATE_SYSTEM_P20_OFFSET ) {\n    return vector * vec3(1.0, -1.0, 1.0);\n  }\n\n  if (u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.0\n    return vector;\n  }\n  return vector;\n}\n\nvec4 project_mvt_offset_position(vec4 position) {\n  float a = COORDINATE_SYSTEM_LNGLAT_OFFSET;\n  float b = COORDINATE_SYSTEM_P20_OFFSET;\n  float c = COORDINATE_SYSTEM_LNGLAT;\n  if (u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET || u_CoordinateSystem == COORDINATE_SYSTEM_P20_OFFSET) {\n    return project_offset(vec4(0.0, 0.0, position.z, position.w));\n  }\n  if (u_CoordinateSystem < COORDINATE_SYSTEM_LNGLAT + 0.01 && u_CoordinateSystem >COORDINATE_SYSTEM_LNGLAT - 0.01) {\n    return vec4(\n      project_mercator(position.xy) * WORLD_SCALE * u_ZoomScale,\n      project_scale(position.z),\n      position.w\n    );\n  }\n  return position;\n}\n\nvec4 project_position(vec4 position) {\n  float a = COORDINATE_SYSTEM_LNGLAT_OFFSET;\n  float b = COORDINATE_SYSTEM_P20_OFFSET;\n  float c = COORDINATE_SYSTEM_LNGLAT;\n  if (u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET\n    || u_CoordinateSystem == COORDINATE_SYSTEM_P20_OFFSET) {\n    float X = position.x - u_ViewportCenter.x;\n    float Y = position.y - u_ViewportCenter.y;\n    return project_offset(vec4(X, Y, position.z, position.w));\n  }\n  if (u_CoordinateSystem < COORDINATE_SYSTEM_LNGLAT + 0.01 && u_CoordinateSystem >COORDINATE_SYSTEM_LNGLAT - 0.01) {\n    return vec4(\n      project_mercator(position.xy) * WORLD_SCALE * u_ZoomScale,\n      project_scale(position.z),\n      position.w\n    );\n  }\n  if (u_CoordinateSystem == COORDINATE_SYSTEM_P20) {\n    return vec4(\n      (project_mercator(position.xy) * WORLD_SCALE * u_ZoomScale - vec2(215440491., 106744817.)) * vec2(1., -1.),\n      project_scale(position.z),\n      position.w\n    );\n  }\n\n  // if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) {\n \n\n  //    return vec4(\n  //     position.xy,\n  //     project_scale(position.z),\n  //     position.w);\n  // }\n  return position;\n\n  // TODO: \u74E6\u7247\u5750\u6807\u7CFB & \u5E38\u89C4\u4E16\u754C\u5750\u6807\u7CFB\n}\nvec2 project_pixel_size_to_clipspace(vec2 pixels) {\n  vec2 offset = pixels / u_ViewportSize * u_DevicePixelRatio * 2.0;\n  return offset * u_FocalDistance;\n}\n\n\n\nfloat project_pixel_allmap(float pixel) {\n  if(u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT) {\n    return pixel * pow(2.0, u_Zoom);\n  }\n  return pixel * u_FocalDistance ;\n}\n\n// \u9002\u914D\u7EB9\u7406\u8D34\u56FE\u7684\u7B49\u50CF\u7D20\u5927\u5C0F\nfloat project_pixel_texture(float pixel) {\n  // mapbox zoom > 12\n  if(u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET) {\n    return pixel * pow(0.5, u_Zoom) * u_FocalDistance ;\n  }\n\n  // amap2 zoom > 12\n  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) {\n    return pixel * pow(2.0, (19.0 - 3.0 - u_Zoom))* u_FocalDistance ;\n  }\n\n  // amap zoom > 12\n  if (u_CoordinateSystem == COORDINATE_SYSTEM_P20_OFFSET) {\n    return pixel * pow(0.5, u_Zoom)* u_FocalDistance ;\n  }\n\n  // amap zoom < 12\n  if (u_CoordinateSystem == COORDINATE_SYSTEM_P20) {\n    return pixel * pow(2.0, (20.0 - u_Zoom))* u_FocalDistance ;\n  }\n  return pixel * 2.0 *  u_FocalDistance;;\n}\n\n// \u5728\u4E0D\u8BBA\u4EC0\u4E48\u5E95\u56FE\u4E0B\u9700\u8981\u7EDF\u4E00\u5904\u7406\u7684\u65F6\u5019\u4F7F\u7528\nfloat project_float_pixel(float pixel) {\n  if (u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT || u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET) {\n    // mapbox P20 \u5750\u6807\u7CFB\u4E0B\uFF0C\u4E3A\u4E86\u548C Web \u58A8\u5361\u6258\u5750\u6807\u7CFB\u7EDF\u4E00\uFF0Czoom \u9ED8\u8BA4\u51CF1\n    return pixel * pow(2.0, (19.0 - u_Zoom))  * u_FocalDistance ;\n  }\n  if (u_CoordinateSystem == COORDINATE_SYSTEM_P20 || u_CoordinateSystem == COORDINATE_SYSTEM_P20_OFFSET) {\n    // amap P20 \u5750\u6807\u7CFB\u4E0B\uFF0C\u4E3A\u4E86\u548C Web \u58A8\u5361\u6258\u5750\u6807\u7CFB\u7EDF\u4E00\uFF0Czoom \u9ED8\u8BA4\u51CF1\n    return pixel * pow(2.0, (19.0 - u_Zoom));\n  }\n  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) {\n    // amap2 P20_2 \u5750\u6807\u7CFB\u4E0B\uFF0C\u4E3A\u4E86\u548C Web \u58A8\u5361\u6258\u5750\u6807\u7CFB\u7EDF\u4E00\uFF0Czoom \u9ED8\u8BA4\u51CF3\n    return pixel * pow(2.0, (19.0 - 3.0 - u_Zoom))* u_FocalDistance ;\n  }\n  return pixel * u_FocalDistance;\n}\n\n// Project meter into the unit of pixel which used in the camera world space\nfloat project_float_meter(float meter) {\n  if (u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT || u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET) {\n    // Since the zoom level uniform is updated by mapservice and it's alread been subtracted by 1\n    // Not sure if we are supposed to do that again\n   return meter;\n  } else  {\n    return project_float_pixel(meter);\n  }\n\n  // TODO: change the following code to make adaptations for amap\n  // return u_FocalDistance * TILE_SIZE * pow(2.0, u_Zoom) * meter / EARTH_CIRCUMFERENCE;\n}\n\nfloat project_pixel(float pixel) {\n  if (u_CoordinateSystem == COORDINATE_SYSTEM_P20 || u_CoordinateSystem == COORDINATE_SYSTEM_P20_OFFSET) {\n    // amap P20 \u5750\u6807\u7CFB\u4E0B\uFF0C\u4E3A\u4E86\u548C Web \u58A8\u5361\u6258\u5750\u6807\u7CFB\u7EDF\u4E00\uFF0Czoom \u9ED8\u8BA4\u51CF1\n    return pixel * pow(2.0, (19.0 - u_Zoom)) * u_FocalDistance ;\n  }\n  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) {\n    // amap2 P20_2 \u5750\u6807\u7CFB\u4E0B\uFF0C\u4E3A\u4E86\u548C Web \u58A8\u5361\u6258\u5750\u6807\u7CFB\u7EDF\u4E00\uFF0Czoom \u9ED8\u8BA4\u51CF3\n    return pixel * pow(2.0, (19.0 - 3.0 - u_Zoom)) * u_FocalDistance ;\n  }\n  return pixel * u_FocalDistance;\n}\nvec2 project_pixel(vec2 pixel) {\n  if (u_CoordinateSystem == COORDINATE_SYSTEM_P20 || u_CoordinateSystem == COORDINATE_SYSTEM_P20_OFFSET) {\n    // P20 \u5750\u6807\u7CFB\u4E0B\uFF0C\u4E3A\u4E86\u548C Web \u58A8\u5361\u6258\u5750\u6807\u7CFB\u7EDF\u4E00\uFF0Czoom \u9ED8\u8BA4\u51CF1\n    return pixel * pow(2.0, (19.0 - u_Zoom)) * u_FocalDistance ;\n  }\n  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) {\n    // P20_2 \u5750\u6807\u7CFB\u4E0B\uFF0C\u4E3A\u4E86\u548C Web \u58A8\u5361\u6258\u5750\u6807\u7CFB\u7EDF\u4E00\uFF0Czoom \u9ED8\u8BA4\u51CF3\n    return pixel * pow(2.0, (19.0 - 3.0 - u_Zoom)) * u_FocalDistance ;\n  }\n  return pixel * -1. * u_FocalDistance;\n}\nvec3 project_pixel(vec3 pixel) {\n  if (u_CoordinateSystem == COORDINATE_SYSTEM_P20 || u_CoordinateSystem == COORDINATE_SYSTEM_P20_OFFSET) {\n    // P20 \u5750\u6807\u7CFB\u4E0B\uFF0C\u4E3A\u4E86\u548C Web \u58A8\u5361\u6258\u5750\u6807\u7CFB\u7EDF\u4E00\uFF0Czoom \u9ED8\u8BA4\u51CF1\n    return pixel * pow(2.0, (19.0 - u_Zoom)) *  u_FocalDistance ;\n  }\n  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) {\n    // P20_2 \u5750\u6807\u7CFB\u4E0B\uFF0C\u4E3A\u4E86\u548C Web \u58A8\u5361\u6258\u5750\u6807\u7CFB\u7EDF\u4E00\uFF0Czoom \u9ED8\u8BA4\u51CF3\n    return pixel * pow(2.0, (19.0 - 3.0 - u_Zoom))  * u_FocalDistance ;\n  }\n  return pixel * -1. * u_FocalDistance;\n}\n\nvec4 project_common_position_to_clipspace(vec4 position, mat4 viewProjectionMatrix, vec4 center) {\n  if (u_CoordinateSystem == COORDINATE_SYSTEM_METER_OFFSET ||\n    u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET) {\n    // Needs to be divided with project_uCommonUnitsPerMeter\n    position.w *= u_PixelsPerMeter.z;\n  }\n\n  return viewProjectionMatrix * position + center;\n}\n\n// Projects from common space coordinates to clip space\nvec4 project_common_position_to_clipspace(vec4 position) {\n  return project_common_position_to_clipspace(\n    position,\n    u_ViewProjectionMatrix,\n    u_ViewportCenterProjection\n  );\n}\n\nvec4 unproject_clipspace_to_position(vec4 clipspacePos, mat4 u_InverseViewProjectionMatrix) {\n  vec4 pos = u_InverseViewProjectionMatrix * (clipspacePos - u_ViewportCenterProjection);\n\n  if (u_CoordinateSystem == COORDINATE_SYSTEM_METER_OFFSET ||\n    u_CoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSET) {\n    // Needs to be divided with project_uCommonUnitsPerMeter\n     pos.w = pos.w / u_PixelsPerMeter.z;\n  }\n  return pos;\n}\n\n\nbool isEqual( float a,  float b) {\n    return  a< b + 0.001 && a > b - 0.001;\n}\n\n// \u652F\u6301 GaodeV2\u3001Mapbox\nvec4 project_common_position_to_clipspace_v2(vec4 position) {\n  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x\n    return u_Mvp * position;\n  } else {\n    return project_common_position_to_clipspace(position);\n  }\n}\n";
+/* babel-plugin-inline-import '../../shaders/rotation_2d.glsl' */
+const rotation_2d = "vec2 rotate_matrix(vec2 v, float a) {\n    float b = a / 180.0 * 3.1415926535897932384626433832795;\n    float s = sin(b);\n    float c = cos(b);\n    mat2 m = mat2(c, s, -s, c);\n    return m * v;\n}";
+/* babel-plugin-inline-import '../../shaders/scene_uniforms.glsl' */
+const scene_uniforms = "layout(std140) uniform SceneUniforms {\n  mat4 u_ViewMatrix;\n  mat4 u_ProjectionMatrix;\n  mat4 u_ViewProjectionMatrix;\n  mat4 u_ModelMatrix;\n  vec4 u_ViewportCenterProjection;\n  vec3 u_PixelsPerDegree;\n  float u_Zoom;\n  vec3 u_PixelsPerDegree2;\n  float u_ZoomScale;\n  vec3 u_PixelsPerMeter;\n  float u_CoordinateSystem;\n  vec3 u_CameraPosition;\n  float u_DevicePixelRatio;\n  vec2 u_ViewportCenter;\n  vec2 u_ViewportSize;\n  float u_FocalDistance;\n};\n\nlayout(std140) uniform LayerUniforms {\n  mat4 u_Mvp;\n  vec2 u_sceneCenterMercator;\n};\n";
+/* babel-plugin-inline-import '../../shaders/sdf_2d.glsl' */
+const sdf2d = "/**\n * 2D signed distance field functions\n * @see http://www.iquilezles.org/www/articles/distfunctions2d/distfunctions2d.htm\n */\n\nfloat ndot(vec2 a, vec2 b ) { return a.x*b.x - a.y*b.y; }\n\nfloat sdCircle(vec2 p, float r) {\n  return length(p) - r;\n}\n\nfloat sdEquilateralTriangle(vec2 p) {\n  float k = sqrt(3.0);\n  p.x = abs(p.x) - 1.0;\n  p.y = p.y + 1.0/k;\n  if( p.x + k*p.y > 0.0 ) p = vec2(p.x-k*p.y,-k*p.x-p.y)/2.0;\n  p.x -= clamp( p.x, -2.0, 0.0 );\n  return -length(p)*sign(p.y);\n}\n\nfloat sdBox(vec2 p, vec2 b) {\n  vec2 d = abs(p)-b;\n  return length(max(d,vec2(0))) + min(max(d.x,d.y),0.0);\n}\n\nfloat sdPentagon(vec2 p, float r) {\n  vec3 k = vec3(0.809016994,0.587785252,0.726542528);\n  p.x = abs(p.x);\n  p -= 2.0*min(dot(vec2(-k.x,k.y),p),0.0)*vec2(-k.x,k.y);\n  p -= 2.0*min(dot(vec2( k.x,k.y),p),0.0)*vec2( k.x,k.y);\n  p -= vec2(clamp(p.x,-r*k.z,r*k.z),r);\n  return length(p)*sign(p.y);\n}\n\nfloat sdHexagon(vec2 p, float r) {\n  vec3 k = vec3(-0.866025404,0.5,0.577350269);\n  p = abs(p);\n  p -= 2.0*min(dot(k.xy,p),0.0)*k.xy;\n  p -= vec2(clamp(p.x, -k.z*r, k.z*r), r);\n  return length(p)*sign(p.y);\n}\n\nfloat sdOctogon(vec2 p, float r) {\n  vec3 k = vec3(-0.9238795325, 0.3826834323, 0.4142135623 );\n  p = abs(p);\n  p -= 2.0*min(dot(vec2( k.x,k.y),p),0.0)*vec2( k.x,k.y);\n  p -= 2.0*min(dot(vec2(-k.x,k.y),p),0.0)*vec2(-k.x,k.y);\n  p -= vec2(clamp(p.x, -k.z*r, k.z*r), r);\n  return length(p)*sign(p.y);\n}\n\nfloat sdHexagram(vec2 p, float r) {\n  vec4 k=vec4(-0.5,0.8660254038,0.5773502692,1.7320508076);\n  p = abs(p);\n  p -= 2.0*min(dot(k.xy,p),0.0)*k.xy;\n  p -= 2.0*min(dot(k.yx,p),0.0)*k.yx;\n  p -= vec2(clamp(p.x,r*k.z,r*k.w),r);\n  return length(p)*sign(p.y);\n}\n\nfloat sdRhombus(vec2 p, vec2 b) {\n  vec2 q = abs(p);\n  float h = clamp((-2.0*ndot(q,b)+ndot(b,b))/dot(b,b),-1.0,1.0);\n  float d = length( q - 0.5*b*vec2(1.0-h,1.0+h) );\n  return d * sign( q.x*b.y + q.y*b.x - b.x*b.y );\n}\n\nfloat sdVesica(vec2 p, float r, float d) {\n  p = abs(p);\n  float b = sqrt(r*r-d*d); // can delay this sqrt\n  return ((p.y-b)*d>p.x*b)\n          ? length(p-vec2(0.0,b))\n          : length(p-vec2(-d,0.0))-r;\n}\n";
+const precisionRegExp = /precision\s+(high|low|medium)p\s+float/;
+const globalDefaultprecision = '#ifdef GL_FRAGMENT_PRECISION_HIGH\n precision highp float;\n #else\n precision mediump float;\n#endif\n';
+const includeRegExp = /#pragma include (["^+"]?["[a-zA-Z_0-9](.*)"]*?)/g;
+const REGEX_START_OF_MAIN = /void\s+main\s*\([^)]*\)\s*\{\n?/; // Beginning of main
+
+export default class ShaderModuleService {
+  constructor() {
+    _defineProperty(this, "moduleCache", {});
+    _defineProperty(this, "rawContentCache", {});
+  }
+  registerBuiltinModules() {
+    this.destroy();
+    this.registerModule('common', {
+      vs: common,
+      fs: common
+    });
+    this.registerModule('decode', {
+      vs: decode,
+      fs: ''
+    });
+    this.registerModule('scene_uniforms', {
+      vs: scene_uniforms,
+      fs: scene_uniforms
+    });
+    this.registerModule('picking_uniforms', {
+      vs: picking_uniforms,
+      fs: picking_uniforms
+    });
+    this.registerModule('projection', {
+      vs: projection,
+      fs: projection
+    });
+    this.registerModule('project', {
+      vs: project,
+      fs: ''
+    });
+    this.registerModule('sdf_2d', {
+      vs: '',
+      fs: sdf2d
+    });
+    this.registerModule('lighting', {
+      vs: lighting,
+      fs: ''
+    });
+    this.registerModule('light', {
+      vs: light,
+      fs: ''
+    });
+    this.registerModule('picking', {
+      vs: pickingVert,
+      fs: pickingFrag
+    });
+    this.registerModule('rotation_2d', {
+      vs: rotation_2d,
+      fs: ''
+    });
+  }
+  registerModule(moduleName, moduleParams) {
+    // prevent registering the same module multiple times
+    // if (this.rawContentCache[moduleName]) {
+    //   return;
+    // }
+
+    moduleParams.vs = moduleParams.vs.replace(/\r\n/g, '\n'); // 将所有的\r\n替换为\n
+    moduleParams.fs = moduleParams.fs.replace(/\r\n/g, '\n'); // 将所有的\r\n替换为\n
+    const {
+      vs,
+      fs,
+      uniforms: declaredUniforms,
+      inject
+    } = moduleParams;
+    const {
+      content: extractedVS,
+      uniforms: vsUniforms
+    } = extractUniforms(vs);
+    const {
+      content: extractedFS,
+      uniforms: fsUniforms
+    } = extractUniforms(fs);
+    this.rawContentCache[moduleName] = {
+      fs: extractedFS,
+      inject,
+      uniforms: _objectSpread(_objectSpread(_objectSpread({}, vsUniforms), fsUniforms), declaredUniforms),
+      vs: extractedVS
+    };
+  }
+  destroy() {
+    this.moduleCache = {};
+    this.rawContentCache = {};
+  }
+  getModule(moduleName) {
+    // TODO: cache module
+    // if (this.moduleCache[moduleName]) {
+    //   return this.moduleCache[moduleName];
+    // }
+
+    let rawVS = this.rawContentCache[moduleName].vs;
+    let rawFS = this.rawContentCache[moduleName].fs;
+    const inject = this.rawContentCache[moduleName].inject;
+    let declaredUniforms = {};
+    if (inject !== null && inject !== void 0 && inject['vs:#decl']) {
+      // 头部注入
+      rawVS = (inject === null || inject === void 0 ? void 0 : inject['vs:#decl']) + rawVS;
+      declaredUniforms = extractUniforms(inject === null || inject === void 0 ? void 0 : inject['vs:#decl']).uniforms;
+    }
+    if (inject !== null && inject !== void 0 && inject['vs:#main-start']) {
+      // main
+      rawVS = rawVS.replace(REGEX_START_OF_MAIN, match => {
+        return match + (inject === null || inject === void 0 ? void 0 : inject['vs:#main-start']);
+      });
+    }
+    if (inject !== null && inject !== void 0 && inject['fs:#decl']) {
+      // 头部注入
+      rawFS = (inject === null || inject === void 0 ? void 0 : inject['fs:#decl']) + rawFS;
+    }
+    const {
+      content: vs,
+      includeList: vsIncludeList
+    } = this.processModule(rawVS, [], 'vs');
+    const {
+      content: fs,
+      includeList: fsIncludeList
+    } = this.processModule(rawFS, [], 'fs');
+    let compiledFs = '';
+    // TODO: extract uniforms and their default values from GLSL
+    const uniforms = uniq(vsIncludeList.concat(fsIncludeList).concat(moduleName)).reduce((prev, cur) => {
+      return _objectSpread(_objectSpread({}, prev), this.rawContentCache[cur].uniforms);
+    }, _objectSpread({}, declaredUniforms));
+
+    /**
+     * set default precision for fragment shader
+     * https://stackoverflow.com/questions/28540290/why-it-is-necessary-to-set-precision-for-the-fragment-shader
+     */
+    if (!precisionRegExp.test(fs)) {
+      compiledFs = compiledFs + globalDefaultprecision;
+    }
+    compiledFs = compiledFs + fs;
+    let compiledVs = '';
+    if (!precisionRegExp.test(vs)) {
+      compiledVs = compiledVs + globalDefaultprecision;
+    }
+    compiledVs = compiledVs + vs;
+    this.moduleCache[moduleName] = {
+      fs: compiledFs.trim(),
+      uniforms,
+      vs: compiledVs.trim()
+    };
+    return this.moduleCache[moduleName];
+  }
+  processModule(rawContent, includeList, type) {
+    const compiled = rawContent.replace(includeRegExp, (_, strMatch) => {
+      const includeOpt = strMatch.split(' ');
+      const includeName = includeOpt[0].replace(/"/g, '');
+      if (includeList.indexOf(includeName) > -1) {
+        return '';
+      }
+      const txt = this.rawContentCache[includeName][type];
+      includeList.push(includeName);
+      const {
+        content
+      } = this.processModule(txt, includeList, type);
+      return content;
+    });
+    return {
+      content: compiled,
+      includeList
+    };
+  }
+  injectDefines(defines) {
+    const defineStr = Object.keys(defines).reduce((prev, cur) => {
+      return prev + `#define ${cur.toUpperCase()} ${defines[cur]};\n`;
+    }, '\n');
+    return defineStr;
+  }
+}