@antv/l7-renderer 2.19.11 → 2.20.0

package/lib/device/constants.js

@@ -0,0 +1,117 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/device/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  blendEquationMap: () => blendEquationMap,
+  blendFuncMap: () => blendFuncMap,
+  cullFaceMap: () => cullFaceMap,
+  depthFuncMap: () => depthFuncMap,
+  hintMap: () => hintMap,
+  primitiveMap: () => primitiveMap,
+  sizeFormatMap: () => sizeFormatMap,
+  typedArrayCtorMap: () => typedArrayCtorMap,
+  wrapModeMap: () => wrapModeMap
+});
+module.exports = __toCommonJS(constants_exports);
+var import_g_device_api = require("@antv/g-device-api");
+var import_l7_core = require("@antv/l7-core");
+var typedArrayCtorMap = {
+  [import_l7_core.gl.FLOAT]: Float32Array,
+  [import_l7_core.gl.UNSIGNED_BYTE]: Uint8Array,
+  [import_l7_core.gl.SHORT]: Int16Array,
+  [import_l7_core.gl.UNSIGNED_SHORT]: Uint16Array,
+  [import_l7_core.gl.INT]: Int32Array,
+  [import_l7_core.gl.UNSIGNED_INT]: Uint32Array
+};
+var primitiveMap = {
+  [import_l7_core.gl.POINTS]: import_g_device_api.PrimitiveTopology.POINTS,
+  [import_l7_core.gl.LINES]: import_g_device_api.PrimitiveTopology.LINES,
+  [import_l7_core.gl.LINE_LOOP]: import_g_device_api.PrimitiveTopology.LINES,
+  [import_l7_core.gl.LINE_STRIP]: import_g_device_api.PrimitiveTopology.LINE_STRIP,
+  [import_l7_core.gl.TRIANGLES]: import_g_device_api.PrimitiveTopology.TRIANGLES,
+  [import_l7_core.gl.TRIANGLE_FAN]: import_g_device_api.PrimitiveTopology.TRIANGLES,
+  [import_l7_core.gl.TRIANGLE_STRIP]: import_g_device_api.PrimitiveTopology.TRIANGLE_STRIP
+};
+var sizeFormatMap = {
+  [1]: import_g_device_api.Format.F32_R,
+  [2]: import_g_device_api.Format.F32_RG,
+  [3]: import_g_device_api.Format.F32_RGB,
+  [4]: import_g_device_api.Format.F32_RGBA
+};
+var hintMap = {
+  [import_l7_core.gl.STATIC_DRAW]: import_g_device_api.BufferFrequencyHint.STATIC,
+  [import_l7_core.gl.DYNAMIC_DRAW]: import_g_device_api.BufferFrequencyHint.DYNAMIC,
+  [import_l7_core.gl.STREAM_DRAW]: import_g_device_api.BufferFrequencyHint.DYNAMIC
+};
+var wrapModeMap = {
+  [import_l7_core.gl.REPEAT]: import_g_device_api.AddressMode.REPEAT,
+  [import_l7_core.gl.CLAMP_TO_EDGE]: import_g_device_api.AddressMode.CLAMP_TO_EDGE,
+  [import_l7_core.gl.MIRRORED_REPEAT]: import_g_device_api.AddressMode.MIRRORED_REPEAT
+};
+var depthFuncMap = {
+  [import_l7_core.gl.NEVER]: import_g_device_api.CompareFunction.NEVER,
+  [import_l7_core.gl.ALWAYS]: import_g_device_api.CompareFunction.ALWAYS,
+  [import_l7_core.gl.LESS]: import_g_device_api.CompareFunction.LESS,
+  [import_l7_core.gl.LEQUAL]: import_g_device_api.CompareFunction.LEQUAL,
+  [import_l7_core.gl.GREATER]: import_g_device_api.CompareFunction.GREATER,
+  [import_l7_core.gl.GEQUAL]: import_g_device_api.CompareFunction.GEQUAL,
+  [import_l7_core.gl.EQUAL]: import_g_device_api.CompareFunction.EQUAL,
+  [import_l7_core.gl.NOTEQUAL]: import_g_device_api.CompareFunction.NOTEQUAL
+};
+var cullFaceMap = {
+  [import_l7_core.gl.FRONT]: import_g_device_api.CullMode.FRONT,
+  [import_l7_core.gl.BACK]: import_g_device_api.CullMode.BACK
+};
+var blendEquationMap = {
+  [import_l7_core.gl.FUNC_ADD]: import_g_device_api.BlendMode.ADD,
+  [import_l7_core.gl.MIN_EXT]: import_g_device_api.BlendMode.MIN,
+  [import_l7_core.gl.MAX_EXT]: import_g_device_api.BlendMode.MAX,
+  [import_l7_core.gl.FUNC_SUBTRACT]: import_g_device_api.BlendMode.SUBSTRACT,
+  [import_l7_core.gl.FUNC_REVERSE_SUBTRACT]: import_g_device_api.BlendMode.REVERSE_SUBSTRACT
+};
+var blendFuncMap = {
+  [import_l7_core.gl.ZERO]: import_g_device_api.BlendFactor.ZERO,
+  [import_l7_core.gl.ONE]: import_g_device_api.BlendFactor.ONE,
+  [import_l7_core.gl.SRC_COLOR]: import_g_device_api.BlendFactor.SRC,
+  [import_l7_core.gl.ONE_MINUS_SRC_COLOR]: import_g_device_api.BlendFactor.ONE_MINUS_SRC,
+  [import_l7_core.gl.SRC_ALPHA]: import_g_device_api.BlendFactor.SRC_ALPHA,
+  [import_l7_core.gl.ONE_MINUS_SRC_ALPHA]: import_g_device_api.BlendFactor.ONE_MINUS_SRC_ALPHA,
+  [import_l7_core.gl.DST_COLOR]: import_g_device_api.BlendFactor.DST,
+  [import_l7_core.gl.ONE_MINUS_DST_COLOR]: import_g_device_api.BlendFactor.ONE_MINUS_DST,
+  [import_l7_core.gl.DST_ALPHA]: import_g_device_api.BlendFactor.DST_ALPHA,
+  [import_l7_core.gl.ONE_MINUS_DST_ALPHA]: import_g_device_api.BlendFactor.ONE_MINUS_DST_ALPHA,
+  [import_l7_core.gl.CONSTANT_COLOR]: import_g_device_api.BlendFactor.CONST,
+  [import_l7_core.gl.ONE_MINUS_CONSTANT_COLOR]: import_g_device_api.BlendFactor.ONE_MINUS_CONSTANT,
+  [import_l7_core.gl.CONSTANT_ALPHA]: import_g_device_api.BlendFactor.CONST,
+  [import_l7_core.gl.ONE_MINUS_CONSTANT_ALPHA]: import_g_device_api.BlendFactor.ONE_MINUS_CONSTANT,
+  [import_l7_core.gl.SRC_ALPHA_SATURATE]: import_g_device_api.BlendFactor.SRC_ALPHA_SATURATE
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  blendEquationMap,
+  blendFuncMap,
+  cullFaceMap,
+  depthFuncMap,
+  hintMap,
+  primitiveMap,
+  sizeFormatMap,
+  typedArrayCtorMap,
+  wrapModeMap
+});

package/lib/device/index.js

@@ -0,0 +1,189 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+
+// src/device/index.ts
+var device_exports = {};
+__export(device_exports, {
+  default: () => DeviceRendererService
+});
+module.exports = __toCommonJS(device_exports);
+var import_g_device_api = require("@antv/g-device-api");
+var import_inversify = require("inversify");
+var import_reflect_metadata = require("reflect-metadata");
+var import_DeviceAttribute = __toESM(require("./DeviceAttribute"));
+var import_DeviceBuffer = __toESM(require("./DeviceBuffer"));
+var import_DeviceElements = __toESM(require("./DeviceElements"));
+var import_DeviceFramebuffer = __toESM(require("./DeviceFramebuffer"));
+var import_DeviceModel = __toESM(require("./DeviceModel"));
+var import_DeviceTexture2D = __toESM(require("./DeviceTexture2D"));
+var import_webgl = require("./utils/webgl");
+var DeviceRendererService = class {
+  constructor() {
+    this.uniformBuffers = [];
+    this.createModel = (options) => new import_DeviceModel.default(this.device, options);
+    this.createAttribute = (options) => new import_DeviceAttribute.default(this.device, options);
+    this.createBuffer = (options) => new import_DeviceBuffer.default(this.device, options);
+    this.createElements = (options) => new import_DeviceElements.default(this.device, options);
+    this.createTexture2D = (options) => new import_DeviceTexture2D.default(this.device, options);
+    this.createFramebuffer = (options) => new import_DeviceFramebuffer.default(this.device, options);
+    this.useFramebuffer = () => {
+    };
+    this.clear = () => {
+    };
+    this.viewport = ({
+      // x,
+      // y,
+      width,
+      height
+    }) => {
+      this.width = width;
+      this.height = height;
+      this.device.width = width;
+      this.device.height = height;
+    };
+    this.readPixels = () => {
+      return new Uint8Array();
+    };
+    this.getViewportSize = () => {
+      return {
+        // @ts-ignore
+        width: this.device.width,
+        // @ts-ignore
+        height: this.device.height
+      };
+    };
+    this.getContainer = () => {
+      var _a;
+      return (_a = this.canvas) == null ? void 0 : _a.parentElement;
+    };
+    this.getCanvas = () => {
+      return this.canvas;
+    };
+    this.getGLContext = () => {
+      return this.device["gl"];
+    };
+    this.destroy = () => {
+      var _a;
+      this.canvas = null;
+      (_a = this.uniformBuffers) == null ? void 0 : _a.forEach((buffer) => {
+        buffer.destroy();
+      });
+      this.device.destroy();
+    };
+  }
+  async init(canvas, cfg) {
+    const { enableWebGPU, shaderCompilerPath } = cfg;
+    this.canvas = canvas;
+    const deviceContribution = enableWebGPU ? new import_g_device_api.WebGPUDeviceContribution({
+      shaderCompilerPath
+    }) : new import_g_device_api.WebGLDeviceContribution({
+      // Use WebGL2 first and downgrade to WebGL1 if WebGL2 is not supported.
+      targets: ["webgl2", "webgl1"],
+      onContextLost(e) {
+        console.warn("context lost", e);
+      },
+      onContextCreationError(e) {
+        console.warn("context creation error", e);
+      },
+      onContextRestored(e) {
+        console.warn("context restored", e);
+      }
+    });
+    const swapChain = await deviceContribution.createSwapChain(canvas);
+    swapChain.configureSwapChain(canvas.width, canvas.height);
+    this.device = swapChain.getDevice();
+    this.swapChain = swapChain;
+    const gl = this.device["gl"];
+    this.extensionObject = {
+      // @ts-ignore
+      OES_texture_float: !(0, import_webgl.isWebGL2)(gl) && this.device["OES_texture_float"]
+    };
+    const renderTargetTexture = this.device.createTexture({
+      format: import_g_device_api.Format.U8_RGBA_RT,
+      width: canvas.width,
+      height: canvas.height,
+      usage: import_g_device_api.TextureUsage.RENDER_TARGET
+    });
+    this.renderTarget = this.device.createRenderTargetFromTexture(renderTargetTexture);
+    this.mainDepthRT = this.device.createRenderTargetFromTexture(
+      this.device.createTexture({
+        format: import_g_device_api.Format.D24_S8,
+        width: canvas.width,
+        height: canvas.height,
+        usage: import_g_device_api.TextureUsage.RENDER_TARGET
+      })
+    );
+  }
+  beginFrame() {
+    const onscreenTexture = this.swapChain.getOnscreenTexture();
+    this.renderPass = this.device.createRenderPass({
+      colorAttachment: [this.renderTarget],
+      // colorResolveTo: [onscreen ? onscreenTexture : onscreenTexture],
+      colorResolveTo: [onscreenTexture],
+      colorClearColor: [import_g_device_api.TransparentBlack],
+      depthStencilAttachment: this.mainDepthRT,
+      depthClearValue: 1
+    });
+    this.device.renderPass = this.renderPass;
+  }
+  endFrame() {
+    this.device.submitPass(this.renderPass);
+  }
+  getPointSizeRange() {
+    const gl = this.device["gl"];
+    return gl.getParameter(gl.ALIASED_POINT_SIZE_RANGE);
+  }
+  testExtension(name) {
+    return !!this.getGLContext().getExtension(name);
+  }
+  // TODO: 临时方法
+  setState() {
+  }
+  setBaseState() {
+  }
+  setCustomLayerDefaults() {
+  }
+  setDirty(flag) {
+    this.isDirty = flag;
+  }
+  getDirty() {
+    return this.isDirty;
+  }
+};
+DeviceRendererService = __decorateClass([
+  (0, import_inversify.injectable)()
+], DeviceRendererService);

package/lib/device/utils/pipeline.js

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/device/utils/pipeline.ts
+var pipeline_exports = {};
+__export(pipeline_exports, {
+  pipelineEquals: () => pipelineEquals
+});
+module.exports = __toCommonJS(pipeline_exports);
+function pipelineEquals() {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pipelineEquals
+});

package/lib/device/utils/typedarray.js

@@ -0,0 +1,43 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/device/utils/typedarray.ts
+var typedarray_exports = {};
+__export(typedarray_exports, {
+  isTypedArray: () => isTypedArray
+});
+module.exports = __toCommonJS(typedarray_exports);
+var dtypes = {
+  "[object Int8Array]": 5120,
+  "[object Int16Array]": 5122,
+  "[object Int32Array]": 5124,
+  "[object Uint8Array]": 5121,
+  "[object Uint8ClampedArray]": 5121,
+  "[object Uint16Array]": 5123,
+  "[object Uint32Array]": 5125,
+  "[object Float32Array]": 5126,
+  "[object Float64Array]": 5121,
+  "[object ArrayBuffer]": 5121
+};
+function isTypedArray(x) {
+  return Object.prototype.toString.call(x) in dtypes;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isTypedArray
+});

package/lib/device/utils/webgl.js

@@ -0,0 +1,34 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/device/utils/webgl.ts
+var webgl_exports = {};
+__export(webgl_exports, {
+  isWebGL2: () => isWebGL2
+});
+module.exports = __toCommonJS(webgl_exports);
+function isWebGL2(gl) {
+  if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
+    return true;
+  }
+  return Boolean(gl && gl._version === 2);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isWebGL2
+});

package/lib/index.js

@@ -29,11 +29,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  DeviceRendererService: () => import_device.default,
   ReglRendererService: () => import_regl.default
 });
 module.exports = __toCommonJS(src_exports);
+var import_device = __toESM(require("./device"));
 var import_regl = __toESM(require("./regl"));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DeviceRendererService,
   ReglRendererService
 });

package/lib/regl/ReglModel.js

@@ -22,6 +22,7 @@ __export(ReglModel_exports, {
   default: () => ReglModel
 });
 module.exports = __toCommonJS(ReglModel_exports);
+var import_g_device_api = require("@antv/g-device-api");
 var import_l7_core = require("@antv/l7-core");
 var import_l7_utils = require("@antv/l7-utils");
 var import_constants = require("./constants");
@@ -43,6 +44,15 @@ var ReglModel = class {
       cull,
       instances
     } = options;
+    const vendorInfo = {
+      platformString: "WebGL1",
+      glslVersion: "#version 100",
+      explicitBindingLocations: false,
+      separateSamplerTextures: false,
+      viewportOrigin: import_g_device_api.ViewportOrigin.LOWER_LEFT,
+      clipSpaceNearZ: import_g_device_api.ClipSpaceNearZ.NEGATIVE_ONE,
+      supportMRT: false
+    };
     const reglUniforms = {};
     this.options = options;
     if (uniforms) {
@@ -57,9 +67,13 @@ var ReglModel = class {
     });
     const drawParams = {
       attributes: reglAttributes,
-      frag: fs,
+      frag: (0, import_l7_core.removeDuplicateUniforms)(
+        (0, import_g_device_api.preprocessShader_GLSL)(vendorInfo, "frag", fs, null, false)
+      ),
       uniforms: reglUniforms,
-      vert: vs,
+      vert: (0, import_l7_core.removeDuplicateUniforms)(
+        (0, import_g_device_api.preprocessShader_GLSL)(vendorInfo, "vert", vs, null, false)
+      ),
       // @ts-ignore
       colorMask: reGl.prop("colorMask"),
       lineWidth: 1,

package/lib/regl/index.js

@@ -52,6 +52,7 @@ var import_ReglModel = __toESM(require("./ReglModel"));
 var import_ReglTexture2D = __toESM(require("./ReglTexture2D"));
 var ReglRendererService = class {
   constructor() {
+    this.uniformBuffers = [];
     this.createModel = (options) => new import_ReglModel.default(this.gl, options);
     this.createAttribute = (options) => new import_ReglAttribute.default(this.gl, options);
     this.createBuffer = (options) => new import_ReglBuffer.default(this.gl, options);
@@ -226,6 +227,10 @@ var ReglRendererService = class {
   getDirty() {
     return this.isDirty;
   }
+  beginFrame() {
+  }
+  endFrame() {
+  }
 };
 ReglRendererService = __decorateClass([
   (0, import_inversify.injectable)()

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@antv/l7-renderer",
-  "version": "2.19.11",
+  "version": "2.20.0",
   "description": "",
+  "license": "ISC",
+  "author": "xiaoiver",
+  "sideEffects": false,
   "main": "lib/index.js",
   "module": "es/index.js",
   "types": "es/index.d.ts",
-  "sideEffects": false,
   "files": [
     "lib",
     "es",
@@ -13,31 +15,29 @@
   ],
   "scripts": {
     "tsc": "tsc --project tsconfig.build.json",
-    "clean": "rimraf dist; rimraf es; rimraf lib;",
     "build": "father build",
     "build:cjs": "BABEL_ENV=cjs babel src --root-mode upward --out-dir lib --source-maps --extensions .ts,.tsx --delete-dir-on-start --no-comments",
     "build:esm": "BABEL_ENV=esm babel src --root-mode upward --out-dir es --source-maps --extensions .ts,.tsx --delete-dir-on-start --no-comments",
-    "watch": "BABEL_ENV=cjs babel src --watch --root-mode upward --out-dir lib --source-maps --extensions .ts,.tsx --delete-dir-on-start --no-comments",
+    "clean": "rimraf dist; rimraf es; rimraf lib;",
     "sync": "tnpm sync",
     "test": "umi-test --passWithNoTests",
     "test-live": "umi-test --watch"
   },
-  "author": "xiaoiver",
-  "license": "ISC",
-  "devDependencies": {
-    "@antv/l7-test-utils": "2.19.11",
-    "gl": "^5.0.3"
-  },
   "dependencies": {
-    "@antv/l7-core": "2.19.11",
-    "@antv/l7-utils": "2.19.11",
+    "@antv/g-device-api": "^1.3.6",
+    "@antv/l7-core": "2.20.0",
+    "@antv/l7-utils": "2.20.0",
     "@babel/runtime": "^7.7.7",
     "inversify": "^5.0.1",
     "reflect-metadata": "^0.1.13",
-    "regl": "1.7.0"
+    "regl": "1.6.1"
+  },
+  "devDependencies": {
+    "@antv/l7-test-utils": "2.20.0",
+    "gl": "^6.0.2"
   },
-  "gitHead": "a16cafc9907fb3a118ee97df82832c88e114446d",
   "publishConfig": {
     "access": "public"
-  }
+  },
+  "gitHead": "6b1a6b52bae44b05336459d4d80f7cace21da6f1"
 }