@antv/l7-renderer 2.25.7 → 2.25.9

package/lib/device/DeviceModel.js

@@ -0,0 +1,495 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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));
+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);
+
+// src/device/DeviceModel.ts
+var DeviceModel_exports = {};
+__export(DeviceModel_exports, {
+  default: () => DeviceModel
+});
+module.exports = __toCommonJS(DeviceModel_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_DeviceFramebuffer = __toESM(require("./DeviceFramebuffer"));
+var import_DeviceTexture2D = __toESM(require("./DeviceTexture2D"));
+var import_constants = require("./constants");
+var { isPlainObject, isTypedArray, isNil } = import_l7_utils.lodashUtil;
+var DeviceModel = class {
+  constructor(device, options, service) {
+    this.device = device;
+    this.options = options;
+    this.service = service;
+    this.destroyed = false;
+    this.uniforms = {};
+    this.vertexBuffers = [];
+    // Pipeline cache to avoid recreating pipeline on every draw call
+    this.pipelineCache = /* @__PURE__ */ new Map();
+    this.currentPipelineKey = "";
+    const { vs, fs, attributes, uniforms, count, elements, diagnosticDerivativeUniformityEnabled } = options;
+    this.options = options;
+    const diagnosticDerivativeUniformityHeader = diagnosticDerivativeUniformityEnabled ? "" : this.service["viewportOrigin"] === import_g_device_api.ViewportOrigin.UPPER_LEFT ? "diagnostic(off,derivative_uniformity);" : "";
+    this.program = service.renderCache.createProgram({
+      vertex: {
+        glsl: vs
+      },
+      fragment: {
+        glsl: fs,
+        postprocess: (fs2) => diagnosticDerivativeUniformityHeader + fs2
+      }
+    });
+    if (uniforms) {
+      this.uniforms = this.extractUniforms(uniforms);
+    }
+    const vertexBufferDescriptors = [];
+    let inferredCount = 0;
+    Object.keys(attributes).forEach((name) => {
+      const attribute = attributes[name];
+      const buffer = attribute.get();
+      this.vertexBuffers.push(buffer.get());
+      const {
+        offset = 0,
+        stride = 0,
+        // TODO: normalized
+        size = 1,
+        divisor = 0,
+        shaderLocation = 0
+      } = attribute["attribute"];
+      vertexBufferDescriptors.push({
+        arrayStride: stride || size * 4,
+        // TODO: L7 hasn't use instanced array for now.
+        stepMode: import_g_device_api.VertexStepMode.VERTEX,
+        attributes: [
+          {
+            format: import_constants.sizeFormatMap[size],
+            shaderLocation,
+            offset,
+            divisor
+          }
+        ]
+      });
+      inferredCount = buffer["size"] / size;
+    });
+    if (!count) {
+      this.options.count = inferredCount;
+    }
+    if (elements) {
+      this.indexBuffer = elements.get();
+    }
+    const inputLayout = service.renderCache.createInputLayout({
+      vertexBufferDescriptors,
+      indexBufferFormat: elements ? import_g_device_api.Format.U32_R : null,
+      program: this.program
+    });
+    this.inputLayout = inputLayout;
+    this.pipeline = this.createPipeline(options);
+    const initialKey = this.getPipelineKey(options);
+    this.pipelineCache.set(initialKey, this.pipeline);
+    this.currentPipelineKey = initialKey;
+  }
+  /**
+   * 生成 Pipeline 缓存键，用于判断是否需要重新创建 Pipeline
+   * 包含所有影响 Pipeline 创建的参数
+   * 注意：当 blend/stencil 禁用时，使用简化的 key 以避免创建重复 Pipeline
+   */
+  getPipelineKey(options, pick) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J;
+    const { primitive = import_l7_core.gl.TRIANGLES, depth, cull, blend, stencil } = options;
+    let stencilKey;
+    if (stencil == null ? void 0 : stencil.enable) {
+      stencilKey = [
+        1,
+        // enabled
+        (_a = stencil.mask) != null ? _a : 4294967295,
+        (_c = (_b = stencil.func) == null ? void 0 : _b.cmp) != null ? _c : import_l7_core.gl.ALWAYS,
+        (_e = (_d = stencil.func) == null ? void 0 : _d.ref) != null ? _e : 0,
+        (_g = (_f = stencil.func) == null ? void 0 : _f.mask) != null ? _g : 4294967295,
+        (_i = (_h = stencil.opFront) == null ? void 0 : _h.fail) != null ? _i : import_l7_core.gl.KEEP,
+        (_k = (_j = stencil.opFront) == null ? void 0 : _j.zfail) != null ? _k : import_l7_core.gl.KEEP,
+        (_m = (_l = stencil.opFront) == null ? void 0 : _l.zpass) != null ? _m : import_l7_core.gl.KEEP,
+        (_o = (_n = stencil.opBack) == null ? void 0 : _n.fail) != null ? _o : import_l7_core.gl.KEEP,
+        (_q = (_p = stencil.opBack) == null ? void 0 : _p.zfail) != null ? _q : import_l7_core.gl.KEEP,
+        (_s = (_r = stencil.opBack) == null ? void 0 : _r.zpass) != null ? _s : import_l7_core.gl.KEEP
+      ].join(",");
+    } else {
+      stencilKey = "0";
+    }
+    let blendKey;
+    if (blend == null ? void 0 : blend.enable) {
+      blendKey = [
+        1,
+        // enabled
+        (_u = (_t = blend.func) == null ? void 0 : _t.srcRGB) != null ? _u : import_l7_core.gl.SRC_ALPHA,
+        (_w = (_v = blend.func) == null ? void 0 : _v.dstRGB) != null ? _w : import_l7_core.gl.ONE_MINUS_SRC_ALPHA,
+        (_y = (_x = blend.func) == null ? void 0 : _x.srcAlpha) != null ? _y : import_l7_core.gl.SRC_ALPHA,
+        (_A = (_z = blend.func) == null ? void 0 : _z.dstAlpha) != null ? _A : import_l7_core.gl.ONE_MINUS_SRC_ALPHA,
+        (_C = (_B = blend.equation) == null ? void 0 : _B.rgb) != null ? _C : import_l7_core.gl.FUNC_ADD,
+        (_E = (_D = blend.equation) == null ? void 0 : _D.alpha) != null ? _E : import_l7_core.gl.FUNC_ADD
+      ].join(",");
+    } else {
+      blendKey = "0";
+    }
+    const parts = [
+      `primitive:${primitive}`,
+      `pick:${!!pick}`,
+      `depth:${(_F = depth == null ? void 0 : depth.enable) != null ? _F : true}:${(_G = depth == null ? void 0 : depth.func) != null ? _G : import_l7_core.gl.LESS}:${(_H = depth == null ? void 0 : depth.mask) != null ? _H : true}`,
+      `cull:${(_I = cull == null ? void 0 : cull.enable) != null ? _I : false}:${(_J = cull == null ? void 0 : cull.face) != null ? _J : import_l7_core.gl.BACK}`,
+      `blend:${blendKey}`,
+      `stencil:${stencilKey}`
+    ];
+    return parts.join("|");
+  }
+  createPipeline(options, pick) {
+    var _a;
+    const { primitive = import_l7_core.gl.TRIANGLES, depth, cull, blend, stencil } = options;
+    const depthParams = this.initDepthDrawParams({ depth });
+    const depthEnabled = !!(depthParams && depthParams.enable);
+    const cullParams = this.initCullDrawParams({ cull });
+    const cullEnabled = !!(cullParams && cullParams.enable);
+    const blendParams = this.getBlendDrawParams({ blend });
+    const blendEnabled = !!(blendParams && blendParams.enable);
+    const stencilParams = this.getStencilDrawParams({ stencil });
+    const stencilEnabled = !!(stencilParams && stencilParams.enable);
+    const pipeline = this.device.createRenderPipeline({
+      inputLayout: this.inputLayout,
+      program: this.program,
+      topology: import_constants.primitiveMap[primitive],
+      colorAttachmentFormats: [import_g_device_api.Format.U8_RGBA_RT],
+      depthStencilAttachmentFormat: import_g_device_api.Format.D24_S8,
+      megaStateDescriptor: {
+        attachmentsState: [
+          pick ? {
+            channelWriteMask: import_g_device_api.ChannelWriteMask.ALL,
+            rgbBlendState: {
+              blendMode: import_g_device_api.BlendMode.ADD,
+              blendSrcFactor: import_g_device_api.BlendFactor.ONE,
+              blendDstFactor: import_g_device_api.BlendFactor.ZERO
+            },
+            alphaBlendState: {
+              blendMode: import_g_device_api.BlendMode.ADD,
+              blendSrcFactor: import_g_device_api.BlendFactor.ONE,
+              blendDstFactor: import_g_device_api.BlendFactor.ZERO
+            }
+          } : {
+            channelWriteMask: stencilEnabled && stencilParams.opFront.zpass === import_g_device_api.StencilOp.REPLACE ? import_g_device_api.ChannelWriteMask.NONE : import_g_device_api.ChannelWriteMask.ALL,
+            rgbBlendState: {
+              blendMode: blendEnabled && blendParams.equation.rgb || import_g_device_api.BlendMode.ADD,
+              blendSrcFactor: blendEnabled && blendParams.func.srcRGB || import_g_device_api.BlendFactor.SRC_ALPHA,
+              blendDstFactor: blendEnabled && blendParams.func.dstRGB || import_g_device_api.BlendFactor.ONE_MINUS_SRC_ALPHA
+            },
+            alphaBlendState: {
+              blendMode: blendEnabled && blendParams.equation.alpha || import_g_device_api.BlendMode.ADD,
+              blendSrcFactor: blendEnabled && blendParams.func.srcAlpha || import_g_device_api.BlendFactor.ONE,
+              blendDstFactor: blendEnabled && blendParams.func.dstAlpha || import_g_device_api.BlendFactor.ONE
+            }
+          }
+        ],
+        blendConstant: blendEnabled ? import_g_device_api.TransparentBlack : void 0,
+        depthWrite: depthEnabled,
+        depthCompare: depthEnabled && depthParams.func || import_g_device_api.CompareFunction.LESS,
+        cullMode: cullEnabled && cullParams.face || import_g_device_api.CullMode.NONE,
+        stencilWrite: stencilEnabled,
+        stencilFront: {
+          compare: stencilEnabled ? stencilParams.func.cmp : import_g_device_api.CompareFunction.ALWAYS,
+          passOp: stencilParams.opFront.zpass,
+          failOp: stencilParams.opFront.fail,
+          depthFailOp: stencilParams.opFront.zfail,
+          mask: stencilParams.opFront.mask
+        },
+        stencilBack: {
+          compare: stencilEnabled ? stencilParams.func.cmp : import_g_device_api.CompareFunction.ALWAYS,
+          passOp: stencilParams.opBack.zpass,
+          failOp: stencilParams.opBack.fail,
+          depthFailOp: stencilParams.opBack.zfail,
+          mask: stencilParams.opBack.mask
+        }
+      }
+    });
+    if (stencilEnabled && !isNil((_a = stencil == null ? void 0 : stencil.func) == null ? void 0 : _a.ref)) {
+      pipeline.stencilFuncReference = stencil.func.ref;
+    }
+    return pipeline;
+  }
+  updateAttributesAndElements() {
+  }
+  /**
+   * No need to implement this method, you should update data on `Attribute` like this:
+   *
+   * @example
+   * ```ts
+   * attribute.updateBuffer({
+   *   data: [],
+   *   offset: 0,
+   * });
+   * ```
+   */
+  updateAttributes() {
+  }
+  addUniforms(uniforms) {
+    this.uniforms = __spreadValues(__spreadValues({}, this.uniforms), this.extractUniforms(uniforms));
+  }
+  draw(options, pick) {
+    const mergedOptions = __spreadValues(__spreadValues({}, this.options), options);
+    const {
+      count = 0,
+      instances,
+      elements,
+      uniforms = {},
+      uniformBuffers,
+      textures
+    } = mergedOptions;
+    this.uniforms = __spreadValues(__spreadValues({}, this.uniforms), this.extractUniforms(uniforms));
+    const { renderPass, currentFramebuffer, width, height } = this.service;
+    const pipelineKey = this.getPipelineKey(mergedOptions, pick);
+    let cachedPipeline = this.pipelineCache.get(pipelineKey);
+    if (!cachedPipeline) {
+      cachedPipeline = this.createPipeline(mergedOptions, pick);
+      this.pipelineCache.set(pipelineKey, cachedPipeline);
+    }
+    this.pipeline = cachedPipeline;
+    this.currentPipelineKey = pipelineKey;
+    const device = this.service["device"];
+    const tmpHeight = device.swapChainHeight;
+    device.swapChainHeight = (currentFramebuffer == null ? void 0 : currentFramebuffer["height"]) || height;
+    renderPass.setViewport(
+      0,
+      0,
+      (currentFramebuffer == null ? void 0 : currentFramebuffer["width"]) || width,
+      (currentFramebuffer == null ? void 0 : currentFramebuffer["height"]) || height
+    );
+    device.swapChainHeight = tmpHeight;
+    renderPass.setPipeline(this.pipeline);
+    const extendedPipeline = this.pipeline;
+    if (!isNil(extendedPipeline.stencilFuncReference)) {
+      renderPass.setStencilReference(extendedPipeline.stencilFuncReference);
+    }
+    renderPass.setVertexInput(
+      this.inputLayout,
+      this.vertexBuffers.map((buffer) => ({
+        buffer
+      })),
+      elements ? {
+        buffer: this.indexBuffer,
+        offset: 0
+      } : null
+    );
+    if (uniformBuffers) {
+      this.bindings = device.createBindings({
+        pipeline: this.pipeline,
+        uniformBufferBindings: uniformBuffers.map((uniformBuffer, i) => {
+          const buffer = uniformBuffer;
+          return {
+            binding: i,
+            buffer: buffer.get(),
+            size: buffer["size"]
+          };
+        }),
+        samplerBindings: textures == null ? void 0 : textures.map((t) => ({
+          texture: t["texture"],
+          sampler: t["sampler"]
+        }))
+      });
+    }
+    if (this.bindings) {
+      renderPass.setBindings(this.bindings);
+      Object.keys(this.uniforms).forEach((uniformName) => {
+        const uniform = this.uniforms[uniformName];
+        if (uniform instanceof import_DeviceTexture2D.default) {
+          this.uniforms[uniformName] = uniform.get();
+        } else if (uniform instanceof import_DeviceFramebuffer.default) {
+          const renderTarget = uniform.get();
+          this.uniforms[uniformName] = renderTarget.texture;
+        }
+      });
+      this.program.setUniformsLegacy(this.uniforms);
+    }
+    if (elements) {
+      const indexCount = elements["count"];
+      if (indexCount === 0) {
+        renderPass.draw(count, instances);
+      } else {
+        renderPass.drawIndexed(indexCount, instances);
+      }
+    } else {
+      renderPass.draw(count, instances);
+    }
+  }
+  destroy() {
+    var _a, _b, _c;
+    (_a = this.vertexBuffers) == null ? void 0 : _a.forEach((buffer) => buffer.destroy());
+    (_b = this.indexBuffer) == null ? void 0 : _b.destroy();
+    (_c = this.bindings) == null ? void 0 : _c.destroy();
+    this.pipelineCache.forEach((pipeline) => pipeline.destroy());
+    this.pipelineCache.clear();
+    this.destroyed = true;
+  }
+  initDepthDrawParams({ depth }) {
+    if (depth) {
+      return {
+        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]
+      };
+    }
+  }
+  getBlendDrawParams({ blend }) {
+    const { enable, func, equation, color = [0, 0, 0, 0] } = blend || {};
+    return {
+      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
+    };
+  }
+  /**
+   * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#stencil
+   */
+  getStencilDrawParams({ stencil }) {
+    const {
+      enable,
+      mask = 4294967295,
+      func = {
+        cmp: import_l7_core.gl.ALWAYS,
+        ref: 0,
+        mask: 4294967295
+      },
+      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 || {};
+    return {
+      enable: !!enable,
+      mask,
+      func: __spreadProps(__spreadValues({}, 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],
+        mask: func.mask
+      },
+      opBack: {
+        fail: import_constants.stencilOpMap[opBack.fail],
+        zfail: import_constants.stencilOpMap[opBack.zfail],
+        zpass: import_constants.stencilOpMap[opBack.zpass],
+        mask: func.mask
+      }
+    };
+  }
+  /**
+   * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#culling
+   */
+  initCullDrawParams({ cull }) {
+    if (cull) {
+      const { enable, face = import_l7_core.gl.BACK } = cull;
+      return {
+        enable: !!enable,
+        face: import_constants.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) {
+    const isPrimitiveType = uniformValue === null || typeof uniformValue === "string" || // 包括空字符串
+    typeof uniformValue === "number" || typeof uniformValue === "boolean" || Array.isArray(uniformValue) && typeof uniformValue[0] === "number" || isTypedArray(uniformValue);
+    if (isPrimitiveType || uniformValue !== null && typeof uniformValue === "object" && "resize" in uniformValue) {
+      uniforms[`${prefix && prefix + "."}${uniformName}`] = uniformValue;
+      return;
+    }
+    if (isPlainObject(uniformValue)) {
+      const obj = uniformValue;
+      Object.keys(obj).forEach((childName) => {
+        this.extractUniformsRecursively(
+          childName,
+          obj[childName],
+          uniforms,
+          `${prefix && prefix + "."}${uniformName}`
+        );
+      });
+    }
+    if (Array.isArray(uniformValue)) {
+      uniformValue.forEach((child, idx) => {
+        if (isPlainObject(child)) {
+          const childObj = child;
+          Object.keys(childObj).forEach((childName) => {
+            this.extractUniformsRecursively(
+              childName,
+              childObj[childName],
+              uniforms,
+              `${prefix && prefix + "."}${uniformName}[${idx}]`
+            );
+          });
+        }
+      });
+    }
+  }
+};

package/lib/device/DeviceTexture2D.d.ts

@@ -0,0 +1,23 @@
+import type { Device, Texture } from '@antv/g-device-api';
+import type { ITexture2D, ITexture2DInitializationOptions } from '@antv/l7-core';
+export declare function isTexture2D(t: any): t is ITexture2D;
+export default class DeviceTexture2D implements ITexture2D {
+    private device;
+    private options;
+    private texture;
+    private sampler;
+    private width;
+    private height;
+    private isDestroy;
+    constructor(device: Device, options: ITexture2DInitializationOptions);
+    private createTexture;
+    get(): Texture;
+    update(props: any): void;
+    bind(): void;
+    resize({ width, height }: {
+        width: number;
+        height: number;
+    }): void;
+    getSize(): [number, number];
+    destroy(): void;
+}

package/lib/device/DeviceTexture2D.js

@@ -0,0 +1,151 @@
+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/DeviceTexture2D.ts
+var DeviceTexture2D_exports = {};
+__export(DeviceTexture2D_exports, {
+  default: () => DeviceTexture2D,
+  isTexture2D: () => isTexture2D
+});
+module.exports = __toCommonJS(DeviceTexture2D_exports);
+var import_g_device_api = require("@antv/g-device-api");
+var import_l7_core = require("@antv/l7-core");
+var import_constants = require("./constants");
+var import_typedarray = require("./utils/typedarray");
+function isTexture2D(t) {
+  return !!(t && t["texture"]);
+}
+var DeviceTexture2D = class {
+  constructor(device, options) {
+    this.device = device;
+    this.options = options;
+    this.isDestroy = false;
+    const {
+      wrapS = import_l7_core.gl.CLAMP_TO_EDGE,
+      wrapT = import_l7_core.gl.CLAMP_TO_EDGE,
+      aniso,
+      mag = import_l7_core.gl.NEAREST,
+      min = import_l7_core.gl.NEAREST
+    } = options;
+    this.createTexture(options);
+    this.sampler = device.createSampler({
+      addressModeU: import_constants.wrapModeMap[wrapS],
+      addressModeV: import_constants.wrapModeMap[wrapT],
+      minFilter: min === import_l7_core.gl.NEAREST ? import_g_device_api.FilterMode.POINT : import_g_device_api.FilterMode.BILINEAR,
+      magFilter: mag === import_l7_core.gl.NEAREST ? import_g_device_api.FilterMode.POINT : import_g_device_api.FilterMode.BILINEAR,
+      mipmapFilter: import_g_device_api.MipmapFilterMode.NO_MIP,
+      // lodMinClamp: 0,
+      // lodMaxClamp: 0,
+      maxAnisotropy: aniso
+    });
+  }
+  createTexture(options) {
+    const {
+      type = import_l7_core.gl.UNSIGNED_BYTE,
+      width,
+      height,
+      flipY = false,
+      format = import_l7_core.gl.RGBA,
+      alignment = 1,
+      usage = import_l7_core.TextureUsage.SAMPLED,
+      // premultiplyAlpha = false,
+      unorm = false,
+      // colorSpace = gl.BROWSER_DEFAULT_WEBGL,
+      // x = 0,
+      // y = 0,
+      // copy = false,
+      label
+    } = options;
+    let { data } = options;
+    this.width = width;
+    this.height = height;
+    let pixelFormat = import_g_device_api.Format.U8_RGBA_RT;
+    if (type === import_l7_core.gl.UNSIGNED_BYTE && format === import_l7_core.gl.RGBA) {
+      pixelFormat = unorm ? import_g_device_api.Format.U8_RGBA_NORM : import_g_device_api.Format.U8_RGBA_RT;
+    } else if (type === import_l7_core.gl.UNSIGNED_BYTE && format === import_l7_core.gl.LUMINANCE) {
+      pixelFormat = import_g_device_api.Format.U8_LUMINANCE;
+    } else if (type === import_l7_core.gl.FLOAT && format === import_l7_core.gl.LUMINANCE) {
+      pixelFormat = import_g_device_api.Format.F32_LUMINANCE;
+    } else if (type === import_l7_core.gl.FLOAT && format === import_l7_core.gl.RGB) {
+      if (this.device.queryVendorInfo().platformString === "WebGPU") {
+        if (data) {
+          data = (0, import_typedarray.extend3ChannelsTo4)(data, 0);
+        }
+        pixelFormat = import_g_device_api.Format.F32_RGBA;
+      } else {
+        pixelFormat = import_g_device_api.Format.F32_RGB;
+      }
+    } else if (type === import_l7_core.gl.FLOAT && format === import_l7_core.gl.RGBA) {
+      pixelFormat = import_g_device_api.Format.F32_RGBA;
+    } else if (type === import_l7_core.gl.FLOAT && format === import_l7_core.gl.RED) {
+      pixelFormat = import_g_device_api.Format.F32_R;
+    } else {
+      throw new Error(`create texture error, type: ${type}, format: ${format}`);
+    }
+    this.texture = this.device.createTexture({
+      format: pixelFormat,
+      width,
+      height,
+      usage: usage === import_l7_core.TextureUsage.SAMPLED ? import_g_device_api.TextureUsage.SAMPLED : import_g_device_api.TextureUsage.RENDER_TARGET,
+      pixelStore: {
+        unpackFlipY: flipY,
+        packAlignment: alignment
+      },
+      // mipLevelCount: usage === TextureUsage.RENDER_TARGET ? 1 : mipmap ? 1 : 0,
+      mipLevelCount: 1
+    });
+    if (label) {
+      this.device.setResourceName(this.texture, label);
+    }
+    if (data) {
+      this.texture.setImageData([data]);
+    }
+  }
+  get() {
+    return this.texture;
+  }
+  update(props) {
+    const { data } = props;
+    this.texture.setImageData([data]);
+  }
+  bind() {
+  }
+  resize({ width, height }) {
+    if (this.width !== width || this.height !== height) {
+      this.destroy();
+    }
+    this.options.width = width;
+    this.options.height = height;
+    this.createTexture(this.options);
+    this.isDestroy = false;
+  }
+  getSize() {
+    return [this.width, this.height];
+  }
+  destroy() {
+    var _a;
+    if (!this.isDestroy && !this.texture.destroyed) {
+      (_a = this.texture) == null ? void 0 : _a.destroy();
+    }
+    this.isDestroy = true;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isTexture2D
+});