@antv/l7-renderer 2.9.32-alpha.2 → 2.9.33

package/lib/regl/ReglAttribute.js

@@ -0,0 +1,51 @@
+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/ReglAttribute.ts
+var ReglAttribute_exports = {};
+__export(ReglAttribute_exports, {
+  default: () => ReglAttribute
+});
+module.exports = __toCommonJS(ReglAttribute_exports);
+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();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/regl/ReglBuffer.js

@@ -0,0 +1,50 @@
+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/ReglBuffer.ts
+var ReglBuffer_exports = {};
+__export(ReglBuffer_exports, {
+  default: () => ReglBuffer
+});
+module.exports = __toCommonJS(ReglBuffer_exports);
+var import_l7_core = require("@antv/l7-core");
+var import_constants = require("./constants");
+var ReglBuffer = class {
+  constructor(reGl, options) {
+    const { data, usage, type } = options;
+    this.buffer = reGl.buffer({
+      data,
+      usage: import_constants.usageMap[usage || import_l7_core.gl.STATIC_DRAW],
+      type: import_constants.dataTypeMap[type || import_l7_core.gl.UNSIGNED_BYTE]
+    });
+  }
+  get() {
+    return this.buffer;
+  }
+  destroy() {
+    this.buffer.destroy();
+  }
+  subData({
+    data,
+    offset
+  }) {
+    this.buffer.subdata(data, offset);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/regl/ReglElements.js

@@ -0,0 +1,49 @@
+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/ReglElements.ts
+var ReglElements_exports = {};
+__export(ReglElements_exports, {
+  default: () => ReglElements
+});
+module.exports = __toCommonJS(ReglElements_exports);
+var import_l7_core = require("@antv/l7-core");
+var import_constants = require("./constants");
+var ReglElements = class {
+  constructor(reGl, options) {
+    const { data, usage, type, count } = options;
+    this.elements = reGl.elements({
+      data,
+      usage: import_constants.usageMap[usage || import_l7_core.gl.STATIC_DRAW],
+      type: import_constants.dataTypeMap[type || import_l7_core.gl.UNSIGNED_BYTE],
+      count
+    });
+  }
+  get() {
+    return this.elements;
+  }
+  subData({
+    data
+  }) {
+    this.elements.subdata(data);
+  }
+  destroy() {
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/regl/ReglFramebuffer.js

@@ -0,0 +1,51 @@
+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/ReglFramebuffer.ts
+var ReglFramebuffer_exports = {};
+__export(ReglFramebuffer_exports, {
+  default: () => ReglFramebuffer
+});
+module.exports = __toCommonJS(ReglFramebuffer_exports);
+var ReglFramebuffer = class {
+  constructor(reGl, options) {
+    const { width, height, color, colors, depth, stencil } = 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);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/regl/ReglModel.js

@@ -0,0 +1,269 @@
+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/ReglModel.ts
+var ReglModel_exports = {};
+__export(ReglModel_exports, {
+  default: () => ReglModel
+});
+module.exports = __toCommonJS(ReglModel_exports);
+var import_l7_core = require("@antv/l7-core");
+var import_lodash = require("lodash");
+var import_constants = require("./constants");
+var ReglModel = class {
+  constructor(reGl, options) {
+    this.destroyed = false;
+    this.uniforms = {};
+    this.reGl = reGl;
+    const {
+      pick = true,
+      vs,
+      fs,
+      attributes,
+      uniforms,
+      primitive,
+      count,
+      elements,
+      depth,
+      blend,
+      stencil,
+      cull,
+      instances
+    } = options;
+    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 drawParams = {
+      attributes: reglAttributes,
+      frag: fs,
+      uniforms: reglUniforms,
+      vert: vs,
+      blend: {},
+      primitive: import_constants.primitiveMap[primitive === void 0 ? import_l7_core.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.initBlendDrawParams({ blend }, drawParams);
+    this.initStencilDrawParams({ stencil }, drawParams);
+    this.initCullDrawParams({ cull }, drawParams);
+    this.drawCommand = reGl(drawParams);
+    if (pick) {
+      const pickDrawParams = (0, import_lodash.cloneDeep)(drawParams);
+      pickDrawParams.blend = {
+        ...pickDrawParams.blend,
+        enable: false
+      };
+      this.drawPickCommand = reGl(pickDrawParams);
+    }
+    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);
+    if (this.options.pick) {
+      const pickDrawParams = (0, import_lodash.cloneDeep)(this.drawParams);
+      pickDrawParams.blend = {
+        ...pickDrawParams.blend,
+        enable: false
+      };
+      this.drawPickCommand = this.reGl(pickDrawParams);
+    }
+  }
+  updateAttributes(attributes) {
+    const reglAttributes = {};
+    Object.keys(attributes).forEach((name) => {
+      reglAttributes[name] = attributes[name].get();
+    });
+    this.drawParams.attributes = reglAttributes;
+    this.drawCommand = this.reGl(this.drawParams);
+    if (this.options.pick) {
+      const pickDrawParams = (0, import_lodash.cloneDeep)(this.drawParams);
+      pickDrawParams.blend = {
+        ...pickDrawParams.blend,
+        enable: false
+      };
+      this.drawPickCommand = this.reGl(pickDrawParams);
+    }
+  }
+  addUniforms(uniforms) {
+    this.uniforms = {
+      ...this.uniforms,
+      ...this.extractUniforms(uniforms)
+    };
+  }
+  draw(options, pick) {
+    if (this.drawParams.attributes && Object.keys(this.drawParams.attributes).length === 0) {
+      return;
+    }
+    const uniforms = {
+      ...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]) || uniforms[uniformName].BYTES_PER_ELEMENT) {
+        reglDrawProps[uniformName] = uniforms[uniformName];
+      } else {
+        reglDrawProps[uniformName] = uniforms[uniformName].get();
+      }
+    });
+    if (!pick) {
+      this.drawCommand(reglDrawProps);
+    } else {
+      this.drawPickCommand && this.drawPickCommand(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;
+  }
+  initDepthDrawParams({ depth }, drawParams) {
+    if (depth) {
+      drawParams.depth = {
+        enable: depth.enable === void 0 ? true : !!depth.enable,
+        mask: depth.mask === void 0 ? true : !!depth.mask,
+        func: import_constants.depthFuncMap[depth.func || import_l7_core.gl.LESS],
+        range: depth.range || [0, 1]
+      };
+    }
+  }
+  initBlendDrawParams({ blend }, drawParams) {
+    if (blend) {
+      const { enable, func, equation, color = [0, 0, 0, 0] } = blend;
+      drawParams.blend = {
+        enable: !!enable,
+        func: {
+          srcRGB: import_constants.blendFuncMap[func && func.srcRGB || import_l7_core.gl.SRC_ALPHA],
+          srcAlpha: import_constants.blendFuncMap[func && func.srcAlpha || import_l7_core.gl.SRC_ALPHA],
+          dstRGB: import_constants.blendFuncMap[func && func.dstRGB || import_l7_core.gl.ONE_MINUS_SRC_ALPHA],
+          dstAlpha: import_constants.blendFuncMap[func && func.dstAlpha || import_l7_core.gl.ONE_MINUS_SRC_ALPHA]
+        },
+        equation: {
+          rgb: import_constants.blendEquationMap[equation && equation.rgb || import_l7_core.gl.FUNC_ADD],
+          alpha: import_constants.blendEquationMap[equation && equation.alpha || import_l7_core.gl.FUNC_ADD]
+        },
+        color
+      };
+    }
+  }
+  initStencilDrawParams({ stencil }, drawParams) {
+    if (stencil) {
+      const {
+        enable,
+        mask = -1,
+        func = {
+          cmp: import_l7_core.gl.ALWAYS,
+          ref: 0,
+          mask: -1
+        },
+        opFront = {
+          fail: import_l7_core.gl.KEEP,
+          zfail: import_l7_core.gl.KEEP,
+          zpass: import_l7_core.gl.KEEP
+        },
+        opBack = {
+          fail: import_l7_core.gl.KEEP,
+          zfail: import_l7_core.gl.KEEP,
+          zpass: import_l7_core.gl.KEEP
+        }
+      } = stencil;
+      drawParams.stencil = {
+        enable: !!enable,
+        mask,
+        func: {
+          ...func,
+          cmp: import_constants.stencilFuncMap[func.cmp]
+        },
+        opFront: {
+          fail: import_constants.stencilOpMap[opFront.fail],
+          zfail: import_constants.stencilOpMap[opFront.zfail],
+          zpass: import_constants.stencilOpMap[opFront.zpass]
+        },
+        opBack: {
+          fail: import_constants.stencilOpMap[opBack.fail],
+          zfail: import_constants.stencilOpMap[opBack.zfail],
+          zpass: import_constants.stencilOpMap[opBack.zpass]
+        }
+      };
+    }
+  }
+  initCullDrawParams({ cull }, drawParams) {
+    if (cull) {
+      const { enable, face = import_l7_core.gl.BACK } = cull;
+      drawParams.cull = {
+        enable: !!enable,
+        face: import_constants.cullFaceMap[face]
+      };
+    }
+  }
+  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" || typeof uniformValue === "boolean" || Array.isArray(uniformValue) && typeof uniformValue[0] === "number" || (0, import_lodash.isTypedArray)(uniformValue) || uniformValue === "" || "resize" in uniformValue) {
+      uniforms[`${prefix && prefix + "."}${uniformName}`] = uniformValue;
+      return;
+    }
+    if ((0, import_lodash.isPlainObject)(uniformValue)) {
+      Object.keys(uniformValue).forEach((childName) => {
+        this.extractUniformsRecursively(childName, uniformValue[childName], uniforms, `${prefix && prefix + "."}${uniformName}`);
+      });
+    }
+    if (Array.isArray(uniformValue)) {
+      uniformValue.forEach((child, idx) => {
+        Object.keys(child).forEach((childName) => {
+          this.extractUniformsRecursively(childName, child[childName], uniforms, `${prefix && prefix + "."}${uniformName}[${idx}]`);
+        });
+      });
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/regl/ReglRenderbuffer.js

@@ -0,0 +1,46 @@
+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/ReglRenderbuffer.ts
+var ReglRenderbuffer_exports = {};
+__export(ReglRenderbuffer_exports, {
+  default: () => ReglRenderbuffer
+});
+module.exports = __toCommonJS(ReglRenderbuffer_exports);
+var import_constants = require("./constants");
+var ReglRenderbuffer = class {
+  constructor(reGl, options) {
+    const { width, height, format } = options;
+    this.renderbuffer = reGl.renderbuffer({
+      width,
+      height,
+      format: import_constants.formatMap[format]
+    });
+  }
+  get() {
+    return this.renderbuffer;
+  }
+  destroy() {
+    this.renderbuffer.destroy();
+  }
+  resize({ width, height }) {
+    this.renderbuffer.resize(width, height);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/regl/ReglTexture2D.js

@@ -0,0 +1,103 @@
+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/ReglTexture2D.ts
+var ReglTexture2D_exports = {};
+__export(ReglTexture2D_exports, {
+  default: () => ReglTexture2D
+});
+module.exports = __toCommonJS(ReglTexture2D_exports);
+var import_l7_core = require("@antv/l7-core");
+var import_constants = require("./constants");
+var ReglTexture2D = class {
+  constructor(reGl, options) {
+    this.isDistroy = false;
+    const {
+      data,
+      type = import_l7_core.gl.UNSIGNED_BYTE,
+      width,
+      height,
+      flipY = false,
+      format = import_l7_core.gl.RGBA,
+      mipmap = false,
+      wrapS = import_l7_core.gl.CLAMP_TO_EDGE,
+      wrapT = import_l7_core.gl.CLAMP_TO_EDGE,
+      aniso = 0,
+      alignment = 1,
+      premultiplyAlpha = false,
+      mag = import_l7_core.gl.NEAREST,
+      min = import_l7_core.gl.NEAREST,
+      colorSpace = import_l7_core.gl.BROWSER_DEFAULT_WEBGL,
+      x = 0,
+      y = 0,
+      copy = false
+    } = options;
+    this.width = width;
+    this.height = height;
+    const textureOptions = {
+      width,
+      height,
+      type: import_constants.dataTypeMap[type],
+      format: import_constants.formatMap[format],
+      wrapS: import_constants.wrapModeMap[wrapS],
+      wrapT: import_constants.wrapModeMap[wrapT],
+      mag: import_constants.filterMap[mag],
+      min: import_constants.filterMap[min],
+      alignment,
+      flipY,
+      colorSpace: import_constants.colorSpaceMap[colorSpace],
+      premultiplyAlpha,
+      aniso,
+      x,
+      y,
+      copy
+    };
+    if (data) {
+      textureOptions.data = data;
+    }
+    if (typeof mipmap === "number") {
+      textureOptions.mipmap = import_constants.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;
+  }
+  destroy() {
+    var _a;
+    if (!this.isDistroy) {
+      (_a = this.texture) == null ? void 0 : _a.destroy();
+    }
+    this.isDistroy = true;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});