@antv/l7-renderer 2.25.7 → 2.25.9

package/es/regl/ReglAttribute.d.ts

@@ -0,0 +1,16 @@
+import type { IAttribute, IAttributeInitializationOptions } from '@antv/l7-core';
+import type regl from 'regl';
+/**
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#attributes
+ */
+export default class ReglAttribute implements IAttribute {
+    private attribute;
+    private buffer;
+    constructor(gl: regl.Regl, options: IAttributeInitializationOptions);
+    get(): regl.Attribute;
+    updateBuffer(options: {
+        data: number[] | number[][] | Uint8Array | Uint16Array | Uint32Array;
+        offset: number;
+    }): void;
+    destroy(): void;
+}

package/es/regl/ReglAttribute.js

@@ -0,0 +1,29 @@
+// src/regl/ReglAttribute.ts
+var ReglAttribute = class {
+  constructor(gl, options) {
+    const { buffer, offset, stride, normalized, size, divisor } = options;
+    this.buffer = buffer;
+    this.attribute = {
+      buffer: buffer.get(),
+      offset: offset || 0,
+      stride: stride || 0,
+      normalized: normalized || false,
+      divisor: divisor || 0
+    };
+    if (size) {
+      this.attribute.size = size;
+    }
+  }
+  get() {
+    return this.attribute;
+  }
+  updateBuffer(options) {
+    this.buffer.subData(options);
+  }
+  destroy() {
+    this.buffer.destroy();
+  }
+};
+export {
+  ReglAttribute as default
+};

package/es/regl/ReglBuffer.d.ts

@@ -0,0 +1,17 @@
+import type { IBuffer, IBufferInitializationOptions } from '@antv/l7-core';
+import type regl from 'regl';
+/**
+ * adaptor for regl.Buffer
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#buffers
+ */
+export default class ReglBuffer implements IBuffer {
+    private buffer;
+    private isDestroyed;
+    constructor(reGl: regl.Regl, options: IBufferInitializationOptions);
+    get(): regl.Buffer;
+    destroy(): void;
+    subData({ data, offset, }: {
+        data: number[] | number[][] | Uint8Array | Uint16Array | Uint32Array;
+        offset: number;
+    }): void;
+}

package/es/regl/ReglBuffer.js

@@ -0,0 +1,33 @@
+// src/regl/ReglBuffer.ts
+import { gl } from "@antv/l7-core";
+import { dataTypeMap, usageMap } from "./constants";
+var ReglBuffer = class {
+  constructor(reGl, options) {
+    this.isDestroyed = false;
+    const { data, usage, type } = options;
+    this.buffer = reGl.buffer({
+      data,
+      usage: usageMap[usage || gl.STATIC_DRAW],
+      type: dataTypeMap[type || gl.UNSIGNED_BYTE]
+      // length: 0,
+    });
+  }
+  get() {
+    return this.buffer;
+  }
+  destroy() {
+    if (!this.isDestroyed) {
+      this.buffer.destroy();
+    }
+    this.isDestroyed = true;
+  }
+  subData({
+    data,
+    offset
+  }) {
+    this.buffer.subdata(data, offset);
+  }
+};
+export {
+  ReglBuffer as default
+};

package/es/regl/ReglElements.d.ts

@@ -0,0 +1,14 @@
+import type { IElements, IElementsInitializationOptions } from '@antv/l7-core';
+import type regl from 'regl';
+/**
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#elements
+ */
+export default class ReglElements implements IElements {
+    private elements;
+    constructor(reGl: regl.Regl, options: IElementsInitializationOptions);
+    get(): regl.Elements;
+    subData({ data, }: {
+        data: number[] | number[][] | Uint8Array | Uint16Array | Uint32Array;
+    }): void;
+    destroy(): void;
+}

package/es/regl/ReglElements.js

@@ -0,0 +1,27 @@
+// src/regl/ReglElements.ts
+import { gl } from "@antv/l7-core";
+import { dataTypeMap, usageMap } from "./constants";
+var ReglElements = class {
+  constructor(reGl, options) {
+    const { data, usage, type, count } = options;
+    this.elements = reGl.elements({
+      data,
+      usage: usageMap[usage || gl.STATIC_DRAW],
+      type: dataTypeMap[type || gl.UNSIGNED_BYTE],
+      count
+    });
+  }
+  get() {
+    return this.elements;
+  }
+  subData({
+    data
+  }) {
+    this.elements.subdata(data);
+  }
+  destroy() {
+  }
+};
+export {
+  ReglElements as default
+};

package/es/regl/ReglFramebuffer.d.ts

@@ -0,0 +1,16 @@
+import type { IFramebuffer, IFramebufferInitializationOptions } from '@antv/l7-core';
+import type regl from 'regl';
+/**
+ * adaptor for regl.Framebuffer
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#framebuffers
+ */
+export default class ReglFramebuffer implements IFramebuffer {
+    private framebuffer;
+    constructor(reGl: regl.Regl, options: IFramebufferInitializationOptions);
+    get(): regl.Framebuffer;
+    destroy(): void;
+    resize({ width, height }: {
+        width: number;
+        height: number;
+    }): void;
+}

package/es/regl/ReglFramebuffer.js

@@ -0,0 +1,31 @@
+// src/regl/ReglFramebuffer.ts
+var ReglFramebuffer = class {
+  constructor(reGl, options) {
+    const { width, height, color, colors } = options;
+    const framebufferOptions = {
+      width,
+      height
+    };
+    if (Array.isArray(colors)) {
+      framebufferOptions.colors = colors.map(
+        (c) => c.get()
+      );
+    }
+    if (color && typeof color !== "boolean") {
+      framebufferOptions.color = color.get();
+    }
+    this.framebuffer = reGl.framebuffer(framebufferOptions);
+  }
+  get() {
+    return this.framebuffer;
+  }
+  destroy() {
+    this.framebuffer.destroy();
+  }
+  resize({ width, height }) {
+    this.framebuffer.resize(width, height);
+  }
+};
+export {
+  ReglFramebuffer as default
+};

package/es/regl/ReglModel.d.ts

@@ -0,0 +1,46 @@
+import type { IAttribute, IElements, IModel, IModelDrawOptions, IModelInitializationOptions, IUniform } from '@antv/l7-core';
+import type regl from 'regl';
+/**
+ * adaptor for regl.DrawCommand
+ */
+export default class ReglModel implements IModel {
+    private reGl;
+    private destroyed;
+    private drawCommand;
+    private drawParams;
+    private options;
+    private uniforms;
+    constructor(reGl: regl.Regl, options: IModelInitializationOptions);
+    updateAttributesAndElements(attributes: {
+        [key: string]: IAttribute;
+    }, elements: IElements): void;
+    updateAttributes(attributes: {
+        [key: string]: IAttribute;
+    }): void;
+    addUniforms(uniforms: {
+        [key: string]: IUniform;
+    }): void;
+    draw(options: IModelDrawOptions, pick?: boolean): void;
+    destroy(): void;
+    /**
+     * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#depth-buffer
+     */
+    private initDepthDrawParams;
+    private getBlendDrawParams;
+    /**
+     * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#stencil
+     */
+    private getStencilDrawParams;
+    private getColorMaskDrawParams;
+    /**
+     * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#culling
+     */
+    private initCullDrawParams;
+    /**
+     * 考虑结构体命名, eg:
+     * a: { b: 1 }  ->  'a.b'
+     * a: [ { b: 1 } ] -> 'a[0].b'
+     */
+    private extractUniforms;
+    private extractUniformsRecursively;
+}

package/es/regl/ReglModel.js

@@ -0,0 +1,302 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/regl/ReglModel.ts
+import { ClipSpaceNearZ, preprocessShader_GLSL, ViewportOrigin } from "@antv/g-device-api";
+import { gl, removeDuplicateUniforms } from "@antv/l7-core";
+import { lodashUtil } from "@antv/l7-utils";
+import {
+  blendEquationMap,
+  blendFuncMap,
+  cullFaceMap,
+  depthFuncMap,
+  primitiveMap,
+  stencilFuncMap,
+  stencilOpMap
+} from "./constants";
+var { isPlainObject, isTypedArray } = lodashUtil;
+var ReglModel = class {
+  constructor(reGl, options) {
+    this.destroyed = false;
+    this.uniforms = {};
+    this.reGl = reGl;
+    const { vs, fs, attributes, uniforms, primitive, count, elements, depth, cull, instances } = options;
+    const vendorInfo = {
+      platformString: "WebGL1",
+      glslVersion: "#version 100",
+      explicitBindingLocations: false,
+      separateSamplerTextures: false,
+      viewportOrigin: ViewportOrigin.LOWER_LEFT,
+      clipSpaceNearZ: ClipSpaceNearZ.NEGATIVE_ONE,
+      supportMRT: false
+    };
+    const reglUniforms = {};
+    this.options = options;
+    if (uniforms) {
+      this.uniforms = this.extractUniforms(uniforms);
+      Object.keys(uniforms).forEach((uniformName) => {
+        reglUniforms[uniformName] = reGl.prop(uniformName);
+      });
+    }
+    const reglAttributes = {};
+    Object.keys(attributes).forEach((name) => {
+      reglAttributes[name] = attributes[name].get();
+    });
+    const frag = removeDuplicateUniforms(
+      preprocessShader_GLSL(vendorInfo, "frag", fs, null, false)
+    );
+    const vert = removeDuplicateUniforms(
+      preprocessShader_GLSL(vendorInfo, "vert", vs, null, false)
+    );
+    const drawParams = {
+      attributes: reglAttributes,
+      frag,
+      uniforms: reglUniforms,
+      vert,
+      // @ts-ignore
+      colorMask: reGl.prop("colorMask"),
+      lineWidth: 1,
+      blend: {
+        // @ts-ignore
+        enable: reGl.prop("blend.enable"),
+        // @ts-ignore
+        func: reGl.prop("blend.func"),
+        // @ts-ignore
+        equation: reGl.prop("blend.equation"),
+        // @ts-ignore
+        color: reGl.prop("blend.color")
+      },
+      stencil: {
+        // @ts-ignore
+        enable: reGl.prop("stencil.enable"),
+        // @ts-ignore
+        mask: reGl.prop("stencil.mask"),
+        // @ts-ignore
+        func: reGl.prop("stencil.func"),
+        // @ts-ignore
+        opFront: reGl.prop("stencil.opFront"),
+        // @ts-ignore
+        opBack: reGl.prop("stencil.opBack")
+      },
+      primitive: primitiveMap[primitive === void 0 ? gl.TRIANGLES : primitive]
+    };
+    if (instances) {
+      drawParams.instances = instances;
+    }
+    if (count) {
+      drawParams.count = count;
+    } else if (elements) {
+      drawParams.elements = elements.get();
+    }
+    this.initDepthDrawParams({ depth }, drawParams);
+    this.initCullDrawParams({ cull }, drawParams);
+    this.drawCommand = reGl(drawParams);
+    this.drawParams = drawParams;
+  }
+  updateAttributesAndElements(attributes, elements) {
+    const reglAttributes = {};
+    Object.keys(attributes).forEach((name) => {
+      reglAttributes[name] = attributes[name].get();
+    });
+    this.drawParams.attributes = reglAttributes;
+    this.drawParams.elements = elements.get();
+    this.drawCommand = this.reGl(this.drawParams);
+  }
+  updateAttributes(attributes) {
+    const reglAttributes = {};
+    Object.keys(attributes).forEach((name) => {
+      reglAttributes[name] = attributes[name].get();
+    });
+    this.drawParams.attributes = reglAttributes;
+    this.drawCommand = this.reGl(this.drawParams);
+  }
+  addUniforms(uniforms) {
+    this.uniforms = __spreadValues(__spreadValues({}, this.uniforms), this.extractUniforms(uniforms));
+  }
+  draw(options, pick) {
+    if (this.drawParams.attributes && Object.keys(this.drawParams.attributes).length === 0) {
+      return;
+    }
+    const uniforms = __spreadValues(__spreadValues({}, this.uniforms), this.extractUniforms(options.uniforms || {}));
+    const reglDrawProps = {};
+    Object.keys(uniforms).forEach((uniformName) => {
+      const type = typeof uniforms[uniformName];
+      if (type === "boolean" || type === "number" || Array.isArray(uniforms[uniformName]) || // @ts-ignore
+      uniforms[uniformName].BYTES_PER_ELEMENT) {
+        reglDrawProps[uniformName] = uniforms[uniformName];
+      } else {
+        reglDrawProps[uniformName] = uniforms[uniformName].get();
+      }
+    });
+    reglDrawProps.blend = pick ? this.getBlendDrawParams({
+      blend: { enable: false }
+    }) : this.getBlendDrawParams(options);
+    reglDrawProps.stencil = this.getStencilDrawParams(options);
+    reglDrawProps.colorMask = this.getColorMaskDrawParams(options, pick);
+    this.drawCommand(reglDrawProps);
+  }
+  destroy() {
+    var _a, _b;
+    (_b = (_a = this.drawParams) == null ? void 0 : _a.elements) == null ? void 0 : _b.destroy();
+    if (this.options.attributes) {
+      Object.values(this.options.attributes).forEach((attr) => {
+        attr == null ? void 0 : attr.destroy();
+      });
+    }
+    this.destroyed = true;
+  }
+  /**
+   * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#depth-buffer
+   */
+  initDepthDrawParams({ depth }, drawParams) {
+    if (depth) {
+      drawParams.depth = {
+        enable: depth.enable === void 0 ? true : !!depth.enable,
+        mask: depth.mask === void 0 ? true : !!depth.mask,
+        func: depthFuncMap[depth.func || gl.LESS],
+        range: depth.range || [0, 1]
+      };
+    }
+  }
+  getBlendDrawParams({ blend }) {
+    const { enable, func, equation, color = [0, 0, 0, 0] } = blend || {};
+    return {
+      enable: !!enable,
+      func: {
+        srcRGB: blendFuncMap[func && func.srcRGB || gl.SRC_ALPHA],
+        srcAlpha: blendFuncMap[func && func.srcAlpha || gl.SRC_ALPHA],
+        dstRGB: blendFuncMap[func && func.dstRGB || gl.ONE_MINUS_SRC_ALPHA],
+        dstAlpha: blendFuncMap[func && func.dstAlpha || gl.ONE_MINUS_SRC_ALPHA]
+      },
+      equation: {
+        rgb: blendEquationMap[equation && equation.rgb || gl.FUNC_ADD],
+        alpha: blendEquationMap[equation && equation.alpha || gl.FUNC_ADD]
+      },
+      color
+    };
+  }
+  /**
+   * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#stencil
+   */
+  getStencilDrawParams({ stencil }) {
+    const {
+      enable,
+      mask = -1,
+      func = {
+        cmp: gl.ALWAYS,
+        ref: 0,
+        mask: -1
+      },
+      opFront = {
+        fail: gl.KEEP,
+        zfail: gl.KEEP,
+        zpass: gl.KEEP
+      },
+      opBack = {
+        fail: gl.KEEP,
+        zfail: gl.KEEP,
+        zpass: gl.KEEP
+      }
+    } = stencil || {};
+    return {
+      enable: !!enable,
+      mask,
+      func: __spreadProps(__spreadValues({}, func), {
+        cmp: stencilFuncMap[func.cmp]
+      }),
+      opFront: {
+        fail: stencilOpMap[opFront.fail],
+        zfail: stencilOpMap[opFront.zfail],
+        zpass: stencilOpMap[opFront.zpass]
+      },
+      opBack: {
+        fail: stencilOpMap[opBack.fail],
+        zfail: stencilOpMap[opBack.zfail],
+        zpass: stencilOpMap[opBack.zpass]
+      }
+    };
+  }
+  getColorMaskDrawParams({ stencil }, pick) {
+    const colorMask = (stencil == null ? void 0 : stencil.enable) && stencil.opFront && !pick ? [false, false, false, false] : [true, true, true, true];
+    return colorMask;
+  }
+  /**
+   * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#culling
+   */
+  initCullDrawParams({ cull }, drawParams) {
+    if (cull) {
+      const { enable, face = gl.BACK } = cull;
+      drawParams.cull = {
+        enable: !!enable,
+        face: cullFaceMap[face]
+      };
+    }
+  }
+  /**
+   * 考虑结构体命名, eg:
+   * a: { b: 1 }  ->  'a.b'
+   * a: [ { b: 1 } ] -> 'a[0].b'
+   */
+  extractUniforms(uniforms) {
+    const extractedUniforms = {};
+    Object.keys(uniforms).forEach((uniformName) => {
+      this.extractUniformsRecursively(uniformName, uniforms[uniformName], extractedUniforms, "");
+    });
+    return extractedUniforms;
+  }
+  extractUniformsRecursively(uniformName, uniformValue, uniforms, prefix) {
+    if (uniformValue === null || typeof uniformValue === "number" || // u_A: 1
+    typeof uniformValue === "boolean" || // u_A: false
+    Array.isArray(uniformValue) && typeof uniformValue[0] === "number" || // u_A: [1, 2, 3]
+    isTypedArray(uniformValue) || // u_A: Float32Array
+    // @ts-ignore
+    uniformValue === "" || "resize" in uniformValue) {
+      uniforms[`${prefix && prefix + "."}${uniformName}`] = uniformValue;
+      return;
+    }
+    if (isPlainObject(uniformValue)) {
+      Object.keys(uniformValue).forEach((childName) => {
+        this.extractUniformsRecursively(
+          childName,
+          // @ts-ignore
+          uniformValue[childName],
+          uniforms,
+          `${prefix && prefix + "."}${uniformName}`
+        );
+      });
+    }
+    if (Array.isArray(uniformValue)) {
+      uniformValue.forEach((child, idx) => {
+        Object.keys(child).forEach((childName) => {
+          this.extractUniformsRecursively(
+            childName,
+            // @ts-ignore
+            child[childName],
+            uniforms,
+            `${prefix && prefix + "."}${uniformName}[${idx}]`
+          );
+        });
+      });
+    }
+  }
+};
+export {
+  ReglModel as default
+};

package/es/regl/ReglRenderbuffer.d.ts

@@ -0,0 +1,16 @@
+import type { IRenderbuffer, IRenderbufferInitializationOptions } from '@antv/l7-core';
+import type regl from 'regl';
+/**
+ * adaptor for regl.Renderbuffer
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#renderbuffers
+ */
+export default class ReglRenderbuffer implements IRenderbuffer {
+    private renderbuffer;
+    constructor(reGl: regl.Regl, options: IRenderbufferInitializationOptions);
+    get(): regl.Renderbuffer;
+    destroy(): void;
+    resize({ width, height }: {
+        width: number;
+        height: number;
+    }): void;
+}

package/es/regl/ReglRenderbuffer.js

@@ -0,0 +1,24 @@
+// src/regl/ReglRenderbuffer.ts
+import { formatMap } from "./constants";
+var ReglRenderbuffer = class {
+  constructor(reGl, options) {
+    const { width, height, format } = options;
+    this.renderbuffer = reGl.renderbuffer({
+      width,
+      height,
+      format: formatMap[format]
+    });
+  }
+  get() {
+    return this.renderbuffer;
+  }
+  destroy() {
+    this.renderbuffer.destroy();
+  }
+  resize({ width, height }) {
+    this.renderbuffer.resize(width, height);
+  }
+};
+export {
+  ReglRenderbuffer as default
+};

package/es/regl/ReglTexture2D.d.ts

@@ -0,0 +1,22 @@
+import type { ITexture2D, ITexture2DInitializationOptions } from '@antv/l7-core';
+import type regl from 'regl';
+/**
+ * adaptor for regl.Buffer
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#buffers
+ */
+export default class ReglTexture2D implements ITexture2D {
+    private texture;
+    private width;
+    private height;
+    private isDestroy;
+    constructor(reGl: regl.Regl, options: ITexture2DInitializationOptions);
+    get(): regl.Texture2D;
+    update(props?: regl.Texture2DOptions): void;
+    bind(): void;
+    resize({ width, height }: {
+        width: number;
+        height: number;
+    }): void;
+    getSize(): [number, number];
+    destroy(): void;
+}

package/es/regl/ReglTexture2D.js

@@ -0,0 +1,94 @@
+// src/regl/ReglTexture2D.ts
+import { gl } from "@antv/l7-core";
+import {
+  colorSpaceMap,
+  dataTypeMap,
+  filterMap,
+  formatMap,
+  mipmapMap,
+  wrapModeMap
+} from "./constants";
+var ReglTexture2D = class {
+  constructor(reGl, options) {
+    this.isDestroy = false;
+    const {
+      data,
+      type = gl.UNSIGNED_BYTE,
+      width,
+      height,
+      flipY = false,
+      format = gl.RGBA,
+      mipmap = false,
+      wrapS = gl.CLAMP_TO_EDGE,
+      wrapT = gl.CLAMP_TO_EDGE,
+      aniso = 0,
+      alignment = 1,
+      premultiplyAlpha = false,
+      mag = gl.NEAREST,
+      min = gl.NEAREST,
+      colorSpace = gl.BROWSER_DEFAULT_WEBGL,
+      x = 0,
+      y = 0,
+      copy = false
+    } = options;
+    this.width = width;
+    this.height = height;
+    const textureOptions = {
+      width,
+      height,
+      // @ts-ignore
+      type: dataTypeMap[type],
+      format: formatMap[format],
+      wrapS: wrapModeMap[wrapS],
+      wrapT: wrapModeMap[wrapT],
+      // @ts-ignore
+      mag: filterMap[mag],
+      min: filterMap[min],
+      alignment,
+      flipY,
+      colorSpace: colorSpaceMap[colorSpace],
+      premultiplyAlpha,
+      aniso,
+      // copy pixels from current bind framebuffer
+      x,
+      y,
+      copy
+    };
+    if (data) {
+      textureOptions.data = data;
+    }
+    if (typeof mipmap === "number") {
+      textureOptions.mipmap = mipmapMap[mipmap];
+    } else if (typeof mipmap === "boolean") {
+      textureOptions.mipmap = mipmap;
+    }
+    this.texture = reGl.texture(textureOptions);
+  }
+  get() {
+    return this.texture;
+  }
+  update(props = {}) {
+    this.texture(props);
+  }
+  bind() {
+    this.texture._texture.bind();
+  }
+  resize({ width, height }) {
+    this.texture.resize(width, height);
+    this.width = width;
+    this.height = height;
+  }
+  getSize() {
+    return [this.width, this.height];
+  }
+  destroy() {
+    var _a;
+    if (!this.isDestroy) {
+      (_a = this.texture) == null ? void 0 : _a.destroy();
+    }
+    this.isDestroy = true;
+  }
+};
+export {
+  ReglTexture2D as default
+};