@antv/l7-renderer 2.25.7 → 2.25.9

package/lib/regl/constants.js

@@ -0,0 +1,170 @@
+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/regl/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  blendEquationMap: () => blendEquationMap,
+  blendFuncMap: () => blendFuncMap,
+  colorSpaceMap: () => colorSpaceMap,
+  cullFaceMap: () => cullFaceMap,
+  dataTypeMap: () => dataTypeMap,
+  depthFuncMap: () => depthFuncMap,
+  filterMap: () => filterMap,
+  formatMap: () => formatMap,
+  mipmapMap: () => mipmapMap,
+  primitiveMap: () => primitiveMap,
+  stencilFuncMap: () => stencilFuncMap,
+  stencilOpMap: () => stencilOpMap,
+  usageMap: () => usageMap,
+  wrapModeMap: () => wrapModeMap
+});
+module.exports = __toCommonJS(constants_exports);
+var import_l7_core = require("@antv/l7-core");
+var primitiveMap = {
+  [import_l7_core.gl.POINTS]: "points",
+  [import_l7_core.gl.LINES]: "lines",
+  [import_l7_core.gl.LINE_LOOP]: "line loop",
+  [import_l7_core.gl.LINE_STRIP]: "line strip",
+  [import_l7_core.gl.TRIANGLES]: "triangles",
+  [import_l7_core.gl.TRIANGLE_FAN]: "triangle fan",
+  [import_l7_core.gl.TRIANGLE_STRIP]: "triangle strip"
+};
+var usageMap = {
+  [import_l7_core.gl.STATIC_DRAW]: "static",
+  [import_l7_core.gl.DYNAMIC_DRAW]: "dynamic",
+  [import_l7_core.gl.STREAM_DRAW]: "stream"
+};
+var dataTypeMap = {
+  [import_l7_core.gl.BYTE]: "int8",
+  // [gl.UNSIGNED_INT]: 'int16',
+  [import_l7_core.gl.INT]: "int32",
+  [import_l7_core.gl.UNSIGNED_BYTE]: "uint8",
+  [import_l7_core.gl.UNSIGNED_SHORT]: "uint16",
+  [import_l7_core.gl.UNSIGNED_INT]: "uint32",
+  [import_l7_core.gl.FLOAT]: "float"
+};
+var formatMap = {
+  [import_l7_core.gl.ALPHA]: "alpha",
+  [import_l7_core.gl.LUMINANCE]: "luminance",
+  [import_l7_core.gl.LUMINANCE_ALPHA]: "luminance alpha",
+  [import_l7_core.gl.RGB]: "rgb",
+  [import_l7_core.gl.RGBA]: "rgba",
+  [import_l7_core.gl.RGBA4]: "rgba4",
+  [import_l7_core.gl.RGB5_A1]: "rgb5 a1",
+  [import_l7_core.gl.RGB565]: "rgb565",
+  [import_l7_core.gl.DEPTH_COMPONENT]: "depth",
+  [import_l7_core.gl.DEPTH_STENCIL]: "depth stencil"
+};
+var mipmapMap = {
+  [import_l7_core.gl.DONT_CARE]: "dont care",
+  [import_l7_core.gl.NICEST]: "nice",
+  [import_l7_core.gl.FASTEST]: "fast"
+};
+var filterMap = {
+  [import_l7_core.gl.NEAREST]: "nearest",
+  [import_l7_core.gl.LINEAR]: "linear",
+  [import_l7_core.gl.LINEAR_MIPMAP_LINEAR]: "mipmap",
+  [import_l7_core.gl.NEAREST_MIPMAP_LINEAR]: "nearest mipmap linear",
+  [import_l7_core.gl.LINEAR_MIPMAP_NEAREST]: "linear mipmap nearest",
+  [import_l7_core.gl.NEAREST_MIPMAP_NEAREST]: "nearest mipmap nearest"
+};
+var wrapModeMap = {
+  [import_l7_core.gl.REPEAT]: "repeat",
+  [import_l7_core.gl.CLAMP_TO_EDGE]: "clamp",
+  [import_l7_core.gl.MIRRORED_REPEAT]: "mirror"
+};
+var colorSpaceMap = {
+  [import_l7_core.gl.NONE]: "none",
+  [import_l7_core.gl.BROWSER_DEFAULT_WEBGL]: "browser"
+};
+var depthFuncMap = {
+  [import_l7_core.gl.NEVER]: "never",
+  [import_l7_core.gl.ALWAYS]: "always",
+  [import_l7_core.gl.LESS]: "less",
+  [import_l7_core.gl.LEQUAL]: "lequal",
+  [import_l7_core.gl.GREATER]: "greater",
+  [import_l7_core.gl.GEQUAL]: "gequal",
+  [import_l7_core.gl.EQUAL]: "equal",
+  [import_l7_core.gl.NOTEQUAL]: "notequal"
+};
+var blendEquationMap = {
+  [import_l7_core.gl.FUNC_ADD]: "add",
+  [import_l7_core.gl.MIN_EXT]: "min",
+  [import_l7_core.gl.MAX_EXT]: "max",
+  [import_l7_core.gl.FUNC_SUBTRACT]: "subtract",
+  [import_l7_core.gl.FUNC_REVERSE_SUBTRACT]: "reverse subtract"
+};
+var blendFuncMap = {
+  [import_l7_core.gl.ZERO]: "zero",
+  [import_l7_core.gl.ONE]: "one",
+  [import_l7_core.gl.SRC_COLOR]: "src color",
+  [import_l7_core.gl.ONE_MINUS_SRC_COLOR]: "one minus src color",
+  [import_l7_core.gl.SRC_ALPHA]: "src alpha",
+  [import_l7_core.gl.ONE_MINUS_SRC_ALPHA]: "one minus src alpha",
+  [import_l7_core.gl.DST_COLOR]: "dst color",
+  [import_l7_core.gl.ONE_MINUS_DST_COLOR]: "one minus dst color",
+  [import_l7_core.gl.DST_ALPHA]: "dst alpha",
+  [import_l7_core.gl.ONE_MINUS_DST_ALPHA]: "one minus dst alpha",
+  [import_l7_core.gl.CONSTANT_COLOR]: "constant color",
+  [import_l7_core.gl.ONE_MINUS_CONSTANT_COLOR]: "one minus constant color",
+  [import_l7_core.gl.CONSTANT_ALPHA]: "constant alpha",
+  [import_l7_core.gl.ONE_MINUS_CONSTANT_ALPHA]: "one minus constant alpha",
+  [import_l7_core.gl.SRC_ALPHA_SATURATE]: "src alpha saturate"
+};
+var stencilFuncMap = {
+  [import_l7_core.gl.NEVER]: "never",
+  [import_l7_core.gl.ALWAYS]: "always",
+  [import_l7_core.gl.LESS]: "less",
+  [import_l7_core.gl.LEQUAL]: "lequal",
+  [import_l7_core.gl.GREATER]: "greater",
+  [import_l7_core.gl.GEQUAL]: "gequal",
+  [import_l7_core.gl.EQUAL]: "equal",
+  [import_l7_core.gl.NOTEQUAL]: "notequal"
+};
+var stencilOpMap = {
+  [import_l7_core.gl.ZERO]: "zero",
+  [import_l7_core.gl.KEEP]: "keep",
+  [import_l7_core.gl.REPLACE]: "replace",
+  [import_l7_core.gl.INVERT]: "invert",
+  [import_l7_core.gl.INCR]: "increment",
+  [import_l7_core.gl.DECR]: "decrement",
+  [import_l7_core.gl.INCR_WRAP]: "increment wrap",
+  [import_l7_core.gl.DECR_WRAP]: "decrement wrap"
+};
+var cullFaceMap = {
+  [import_l7_core.gl.FRONT]: "front",
+  [import_l7_core.gl.BACK]: "back"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  blendEquationMap,
+  blendFuncMap,
+  colorSpaceMap,
+  cullFaceMap,
+  dataTypeMap,
+  depthFuncMap,
+  filterMap,
+  formatMap,
+  mipmapMap,
+  primitiveMap,
+  stencilFuncMap,
+  stencilOpMap,
+  usageMap,
+  wrapModeMap
+});

package/lib/regl/index.d.ts

@@ -0,0 +1,56 @@
+/**
+ * render w/ regl
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md
+ */
+import type { IAttribute, IAttributeInitializationOptions, IBuffer, IBufferInitializationOptions, IClearOptions, IElements, IElementsInitializationOptions, IExtensions, IFramebuffer, IFramebufferInitializationOptions, IModel, IModelInitializationOptions, IReadPixelsOptions, IRenderConfig, IRendererService, ITexture2D, ITexture2DInitializationOptions } from '@antv/l7-core';
+import regl from 'regl';
+import ReglFramebuffer from './ReglFramebuffer';
+/**
+ * regl renderer
+ */
+export default class ReglRendererService implements IRendererService {
+    uniformBuffers: IBuffer[];
+    extensionObject: IExtensions;
+    private gl;
+    private $container;
+    private canvas;
+    private width;
+    private height;
+    private isDirty;
+    queryVerdorInfo: () => string;
+    init(canvas: HTMLCanvasElement, cfg: IRenderConfig, gl?: regl.Regl): Promise<void>;
+    getPointSizeRange(): any;
+    testExtension(name: string): boolean;
+    createModel: (options: IModelInitializationOptions) => IModel;
+    createAttribute: (options: IAttributeInitializationOptions) => IAttribute;
+    createBuffer: (options: IBufferInitializationOptions) => IBuffer;
+    createElements: (options: IElementsInitializationOptions) => IElements;
+    createTexture2D: (options: ITexture2DInitializationOptions) => ITexture2D;
+    createFramebuffer: (options: IFramebufferInitializationOptions) => ReglFramebuffer;
+    useFramebuffer: (framebuffer: IFramebuffer | null, drawCommands: () => void) => void;
+    useFramebufferAsync: (framebuffer: IFramebuffer | null, drawCommands: () => Promise<void>) => Promise<void>;
+    clear: (options: IClearOptions) => void;
+    viewport: ({ x, y, width, height, }: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }) => void;
+    readPixels: (options: IReadPixelsOptions) => Uint8Array;
+    readPixelsAsync: (options: IReadPixelsOptions) => Promise<Uint8Array>;
+    getViewportSize: () => {
+        width: number;
+        height: number;
+    };
+    getContainer: () => HTMLElement | null;
+    getCanvas: () => HTMLCanvasElement;
+    getGLContext: () => WebGLRenderingContext;
+    setState(): void;
+    setBaseState(): void;
+    setCustomLayerDefaults(): void;
+    setDirty(flag: boolean): void;
+    getDirty(): boolean;
+    destroy: () => void;
+    beginFrame(): void;
+    endFrame(): void;
+}

package/lib/regl/index.js

@@ -0,0 +1,256 @@
+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 __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/regl/index.ts
+var regl_exports = {};
+__export(regl_exports, {
+  default: () => ReglRendererService
+});
+module.exports = __toCommonJS(regl_exports);
+var import_regl = __toESM(require("regl"));
+var import_ReglAttribute = __toESM(require("./ReglAttribute"));
+var import_ReglBuffer = __toESM(require("./ReglBuffer"));
+var import_ReglElements = __toESM(require("./ReglElements"));
+var import_ReglFramebuffer = __toESM(require("./ReglFramebuffer"));
+var import_ReglModel = __toESM(require("./ReglModel"));
+var import_ReglTexture2D = __toESM(require("./ReglTexture2D"));
+var ReglRendererService = class {
+  constructor() {
+    this.uniformBuffers = [];
+    this.queryVerdorInfo = () => {
+      return "WebGL1";
+    };
+    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);
+    this.createElements = (options) => new import_ReglElements.default(this.gl, options);
+    this.createTexture2D = (options) => new import_ReglTexture2D.default(this.gl, options);
+    this.createFramebuffer = (options) => new import_ReglFramebuffer.default(this.gl, options);
+    this.useFramebuffer = (framebuffer, drawCommands) => {
+      this.gl({
+        framebuffer: framebuffer ? framebuffer.get() : null
+      })(drawCommands);
+    };
+    this.useFramebufferAsync = (framebuffer, drawCommands) => __async(this, null, function* () {
+      this.gl({
+        framebuffer: framebuffer ? framebuffer.get() : null
+      })(drawCommands);
+    });
+    this.clear = (options) => {
+      var _a;
+      const { color, depth, stencil, framebuffer = null } = options;
+      const reglClearOptions = {
+        color,
+        depth,
+        stencil
+      };
+      reglClearOptions.framebuffer = framebuffer === null ? framebuffer : framebuffer.get();
+      (_a = this.gl) == null ? void 0 : _a.clear(reglClearOptions);
+    };
+    this.viewport = ({
+      x,
+      y,
+      width,
+      height
+    }) => {
+      this.gl._gl.viewport(x, y, width, height);
+      this.width = width;
+      this.height = height;
+      this.gl._refresh();
+    };
+    this.readPixels = (options) => {
+      const { framebuffer, x, y, width, height } = options;
+      const readPixelsOptions = {
+        x,
+        y,
+        width,
+        height
+      };
+      if (framebuffer) {
+        readPixelsOptions.framebuffer = framebuffer.get();
+      }
+      return this.gl.read(readPixelsOptions);
+    };
+    this.readPixelsAsync = (options) => __async(this, null, function* () {
+      return this.readPixels(options);
+    });
+    this.getViewportSize = () => {
+      return {
+        width: this.gl._gl.drawingBufferWidth,
+        height: this.gl._gl.drawingBufferHeight
+      };
+    };
+    this.getContainer = () => {
+      var _a;
+      return (_a = this.canvas) == null ? void 0 : _a.parentElement;
+    };
+    this.getCanvas = () => {
+      return this.canvas;
+    };
+    this.getGLContext = () => {
+      return this.gl._gl;
+    };
+    this.destroy = () => {
+      var _a, _b, _c;
+      this.canvas = null;
+      (_c = (_b = (_a = this.gl) == null ? void 0 : _a._gl) == null ? void 0 : _b.getExtension("WEBGL_lose_context")) == null ? void 0 : _c.loseContext();
+      this.gl.destroy();
+      this.gl = null;
+    };
+  }
+  init(canvas, cfg, gl) {
+    return __async(this, null, function* () {
+      this.canvas = canvas;
+      if (gl) {
+        this.gl = gl;
+      } else {
+        this.gl = yield new Promise((resolve, reject) => {
+          (0, import_regl.default)({
+            canvas: this.canvas,
+            attributes: {
+              alpha: true,
+              // use TAA instead of MSAA
+              // @see https://www.khronos.org/registry/webgl/specs/1.0/#5.2.1
+              antialias: cfg.antialias,
+              premultipliedAlpha: true,
+              preserveDrawingBuffer: cfg.preserveDrawingBuffer,
+              stencil: cfg.stencil
+            },
+            // TODO: use extensions
+            extensions: [
+              "OES_element_index_uint",
+              "OES_standard_derivatives",
+              // wireframe
+              "ANGLE_instanced_arrays"
+              // VSM shadow map
+            ],
+            optionalExtensions: [
+              "oes_texture_float_linear",
+              "OES_texture_float",
+              "EXT_texture_filter_anisotropic",
+              "EXT_blend_minmax",
+              "WEBGL_depth_texture",
+              "WEBGL_lose_context"
+            ],
+            profile: true,
+            onDone: (err, r) => {
+              if (err || !r) {
+                reject(err);
+              }
+              resolve(r);
+            }
+          });
+        });
+      }
+      this.extensionObject = {
+        OES_texture_float: this.testExtension("OES_texture_float")
+      };
+    });
+  }
+  getPointSizeRange() {
+    return this.gl._gl.getParameter(this.gl._gl.ALIASED_POINT_SIZE_RANGE);
+  }
+  testExtension(name) {
+    return !!this.getGLContext().getExtension(name);
+  }
+  // TODO: 临时方法
+  setState() {
+    this.gl({
+      cull: {
+        enable: false,
+        face: "back"
+      },
+      viewport: {
+        x: 0,
+        y: 0,
+        height: this.width,
+        width: this.height
+      },
+      blend: {
+        enable: true,
+        equation: "add"
+      },
+      framebuffer: null
+    });
+    this.gl._refresh();
+  }
+  setBaseState() {
+    this.gl({
+      cull: {
+        enable: false,
+        face: "back"
+      },
+      viewport: {
+        x: 0,
+        y: 0,
+        height: this.width,
+        width: this.height
+      },
+      blend: {
+        enable: false,
+        equation: "add"
+      },
+      framebuffer: null
+    });
+    this.gl._refresh();
+  }
+  setCustomLayerDefaults() {
+    const gl = this.getGLContext();
+    gl.disable(gl.CULL_FACE);
+  }
+  setDirty(flag) {
+    this.isDirty = flag;
+  }
+  getDirty() {
+    return this.isDirty;
+  }
+  beginFrame() {
+  }
+  endFrame() {
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antv/l7-renderer",
-  "version": "2.25.7",
+  "version": "2.25.9",
   "description": "",
   "license": "MIT",
   "author": "https://github.com/orgs/antvis/people",
@@ -16,11 +16,11 @@
     "@antv/g-device-api": "^1.6.4",
     "@babel/runtime": "^7.7.7",
     "regl": "1.6.1",
-    "@antv/l7-utils": "2.25.7",
-    "@antv/l7-core": "2.25.7"
+    "@antv/l7-core": "2.25.9",
+    "@antv/l7-utils": "2.25.9"
   },
   "devDependencies": {
-    "@antv/l7-test-utils": "^2.25.7"
+    "@antv/l7-test-utils": "^2.25.9"
   },
   "publishConfig": {
     "access": "public",