@antv/l7-renderer 2.25.6 → 2.25.7

package/es/device/constants.js

@@ -1,117 +0,0 @@
-// src/device/constants.ts
-import {
-  AddressMode,
-  BlendFactor,
-  BlendMode,
-  BufferFrequencyHint,
-  CompareFunction,
-  CullMode,
-  Format,
-  PrimitiveTopology,
-  StencilOp
-} from "@antv/g-device-api";
-import { gl } from "@antv/l7-core";
-var typedArrayCtorMap = {
-  [gl.FLOAT]: Float32Array,
-  [gl.UNSIGNED_BYTE]: Uint8Array,
-  [gl.SHORT]: Int16Array,
-  [gl.UNSIGNED_SHORT]: Uint16Array,
-  [gl.INT]: Int32Array,
-  [gl.UNSIGNED_INT]: Uint32Array
-};
-var primitiveMap = {
-  [gl.POINTS]: PrimitiveTopology.POINTS,
-  [gl.LINES]: PrimitiveTopology.LINES,
-  [gl.LINE_LOOP]: PrimitiveTopology.LINES,
-  [gl.LINE_STRIP]: PrimitiveTopology.LINE_STRIP,
-  [gl.TRIANGLES]: PrimitiveTopology.TRIANGLES,
-  [gl.TRIANGLE_FAN]: PrimitiveTopology.TRIANGLES,
-  [gl.TRIANGLE_STRIP]: PrimitiveTopology.TRIANGLE_STRIP
-};
-var sizeFormatMap = {
-  [1]: Format.F32_R,
-  [2]: Format.F32_RG,
-  [3]: Format.F32_RGB,
-  [4]: Format.F32_RGBA
-};
-var hintMap = {
-  [gl.STATIC_DRAW]: BufferFrequencyHint.STATIC,
-  [gl.DYNAMIC_DRAW]: BufferFrequencyHint.DYNAMIC,
-  [gl.STREAM_DRAW]: BufferFrequencyHint.DYNAMIC
-};
-var wrapModeMap = {
-  [gl.REPEAT]: AddressMode.REPEAT,
-  [gl.CLAMP_TO_EDGE]: AddressMode.CLAMP_TO_EDGE,
-  [gl.MIRRORED_REPEAT]: AddressMode.MIRRORED_REPEAT
-};
-var depthFuncMap = {
-  [gl.NEVER]: CompareFunction.NEVER,
-  [gl.ALWAYS]: CompareFunction.ALWAYS,
-  [gl.LESS]: CompareFunction.LESS,
-  [gl.LEQUAL]: CompareFunction.LEQUAL,
-  [gl.GREATER]: CompareFunction.GREATER,
-  [gl.GEQUAL]: CompareFunction.GEQUAL,
-  [gl.EQUAL]: CompareFunction.EQUAL,
-  [gl.NOTEQUAL]: CompareFunction.NOTEQUAL
-};
-var cullFaceMap = {
-  [gl.FRONT]: CullMode.FRONT,
-  [gl.BACK]: CullMode.BACK
-};
-var blendEquationMap = {
-  [gl.FUNC_ADD]: BlendMode.ADD,
-  [gl.MIN_EXT]: BlendMode.MIN,
-  [gl.MAX_EXT]: BlendMode.MAX,
-  [gl.FUNC_SUBTRACT]: BlendMode.SUBSTRACT,
-  [gl.FUNC_REVERSE_SUBTRACT]: BlendMode.REVERSE_SUBSTRACT
-};
-var blendFuncMap = {
-  [gl.ZERO]: BlendFactor.ZERO,
-  [gl.ONE]: BlendFactor.ONE,
-  [gl.SRC_COLOR]: BlendFactor.SRC,
-  [gl.ONE_MINUS_SRC_COLOR]: BlendFactor.ONE_MINUS_SRC,
-  [gl.SRC_ALPHA]: BlendFactor.SRC_ALPHA,
-  [gl.ONE_MINUS_SRC_ALPHA]: BlendFactor.ONE_MINUS_SRC_ALPHA,
-  [gl.DST_COLOR]: BlendFactor.DST,
-  [gl.ONE_MINUS_DST_COLOR]: BlendFactor.ONE_MINUS_DST,
-  [gl.DST_ALPHA]: BlendFactor.DST_ALPHA,
-  [gl.ONE_MINUS_DST_ALPHA]: BlendFactor.ONE_MINUS_DST_ALPHA,
-  [gl.CONSTANT_COLOR]: BlendFactor.CONST,
-  [gl.ONE_MINUS_CONSTANT_COLOR]: BlendFactor.ONE_MINUS_CONSTANT,
-  [gl.CONSTANT_ALPHA]: BlendFactor.CONST,
-  [gl.ONE_MINUS_CONSTANT_ALPHA]: BlendFactor.ONE_MINUS_CONSTANT,
-  [gl.SRC_ALPHA_SATURATE]: BlendFactor.SRC_ALPHA_SATURATE
-};
-var stencilOpMap = {
-  [gl.REPLACE]: StencilOp.REPLACE,
-  [gl.KEEP]: StencilOp.KEEP,
-  [gl.ZERO]: StencilOp.ZERO,
-  [gl.INVERT]: StencilOp.INVERT,
-  [gl.INCR]: StencilOp.INCREMENT_CLAMP,
-  [gl.DECR]: StencilOp.DECREMENT_CLAMP,
-  [gl.INCR_WRAP]: StencilOp.INCREMENT_WRAP,
-  [gl.DECR_WRAP]: StencilOp.DECREMENT_WRAP
-};
-var stencilFuncMap = {
-  [gl.ALWAYS]: CompareFunction.ALWAYS,
-  [gl.EQUAL]: CompareFunction.EQUAL,
-  [gl.GEQUAL]: CompareFunction.GEQUAL,
-  [gl.GREATER]: CompareFunction.GREATER,
-  [gl.LEQUAL]: CompareFunction.LEQUAL,
-  [gl.LESS]: CompareFunction.LESS,
-  [gl.NEVER]: CompareFunction.NEVER,
-  [gl.NOTEQUAL]: CompareFunction.NOTEQUAL
-};
-export {
-  blendEquationMap,
-  blendFuncMap,
-  cullFaceMap,
-  depthFuncMap,
-  hintMap,
-  primitiveMap,
-  sizeFormatMap,
-  stencilFuncMap,
-  stencilOpMap,
-  typedArrayCtorMap,
-  wrapModeMap
-};

package/es/device/index.d.ts

@@ -1,68 +0,0 @@
-import type { RenderPass, RenderTarget, SwapChain } from '@antv/g-device-api';
-import type { IAttribute, IAttributeInitializationOptions, IBuffer, IBufferInitializationOptions, IClearOptions, IElements, IElementsInitializationOptions, IExtensions, IFramebuffer, IFramebufferInitializationOptions, IModel, IModelInitializationOptions, IReadPixelsOptions, IRenderConfig, IRendererService, ITexture2D, ITexture2DInitializationOptions } from '@antv/l7-core';
-import { RenderCache } from './DeviceCache';
-import DeviceFramebuffer from './DeviceFramebuffer';
-/**
- * Device API renderer
- */
-export default class DeviceRendererService implements IRendererService {
-    uniformBuffers: IBuffer[];
-    extensionObject: IExtensions;
-    private device;
-    swapChain: SwapChain;
-    private $container;
-    private canvas;
-    width: number;
-    height: number;
-    private isDirty;
-    /**
-     * Current render pass.
-     */
-    renderPass: RenderPass;
-    preRenderPass: RenderPass;
-    mainColorRT: RenderTarget;
-    mainDepthRT: RenderTarget;
-    renderCache: RenderCache;
-    /**
-     * Current FBO.
-     */
-    currentFramebuffer: DeviceFramebuffer | null;
-    queryVerdorInfo: () => string;
-    private viewportOrigin;
-    init(canvas: HTMLCanvasElement, cfg: IRenderConfig): Promise<void>;
-    private createMainColorDepthRT;
-    beginFrame(): void;
-    endFrame(): 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) => DeviceFramebuffer;
-    useFramebuffer: (framebuffer: IFramebuffer | null, drawCommands: () => void) => void;
-    useFramebufferAsync: (framebuffer: IFramebuffer | null, drawCommands: () => Promise<void>) => Promise<void>;
-    clear: (options: IClearOptions) => void;
-    viewport: ({ 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;
-}

package/es/device/index.js

@@ -1,311 +0,0 @@
-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/device/index.ts
-import {
-  Format,
-  TextureUsage,
-  TransparentBlack,
-  ViewportOrigin,
-  WebGLDeviceContribution,
-  WebGPUDeviceContribution,
-  colorNewFromRGBA
-} from "@antv/g-device-api";
-import { lodashUtil } from "@antv/l7-utils";
-import DeviceAttribute from "./DeviceAttribute";
-import DeviceBuffer from "./DeviceBuffer";
-import { RenderCache } from "./DeviceCache";
-import DeviceElements from "./DeviceElements";
-import DeviceFramebuffer from "./DeviceFramebuffer";
-import DeviceModel from "./DeviceModel";
-import DeviceTexture2D from "./DeviceTexture2D";
-import { isWebGL2 } from "./utils/webgl";
-var { isUndefined } = lodashUtil;
-var DeviceRendererService = class {
-  constructor() {
-    this.uniformBuffers = [];
-    this.queryVerdorInfo = () => {
-      return this.device.queryVendorInfo().platformString;
-    };
-    this.createModel = (options) => new DeviceModel(this.device, options, this);
-    this.createAttribute = (options) => new DeviceAttribute(this.device, options);
-    this.createBuffer = (options) => new DeviceBuffer(this.device, options);
-    this.createElements = (options) => new DeviceElements(this.device, options);
-    this.createTexture2D = (options) => new DeviceTexture2D(this.device, options);
-    this.createFramebuffer = (options) => new DeviceFramebuffer(this.device, options);
-    this.useFramebuffer = (framebuffer, drawCommands) => {
-      this.currentFramebuffer = framebuffer;
-      this.beginFrame();
-      drawCommands();
-      this.endFrame();
-      this.currentFramebuffer = null;
-    };
-    this.useFramebufferAsync = (framebuffer, drawCommands) => __async(this, null, function* () {
-      this.currentFramebuffer = framebuffer;
-      this.preRenderPass = this.renderPass;
-      this.beginFrame();
-      yield drawCommands();
-      this.endFrame();
-      this.currentFramebuffer = null;
-      this.renderPass = this.preRenderPass;
-    });
-    this.clear = (options) => {
-      const { color, depth, stencil, framebuffer = null } = options;
-      if (framebuffer) {
-        framebuffer.clearOptions = { color, depth, stencil };
-      } else {
-        const platformString = this.queryVerdorInfo();
-        if (platformString === "WebGL1") {
-          const gl = this.getGLContext();
-          if (!isUndefined(stencil)) {
-            gl.clearStencil(stencil);
-            gl.clear(gl.STENCIL_BUFFER_BIT);
-          } else if (!isUndefined(depth)) {
-            gl.clearDepth(depth);
-            gl.clear(gl.DEPTH_BUFFER_BIT);
-          }
-        } else if (platformString === "WebGL2") {
-          const gl = this.getGLContext();
-          if (!isUndefined(stencil)) {
-            gl.clearBufferiv(gl.STENCIL, 0, [stencil]);
-          } else if (!isUndefined(depth)) {
-            gl.clearBufferfv(gl.DEPTH, 0, [depth]);
-          }
-        }
-      }
-    };
-    this.viewport = ({
-      // x,
-      // y,
-      width,
-      height
-    }) => {
-      this.swapChain.configureSwapChain(width, height);
-      this.createMainColorDepthRT(width, height);
-      this.width = width;
-      this.height = height;
-    };
-    this.readPixels = (options) => {
-      const { framebuffer, x, y, width, height } = options;
-      const readback = this.device.createReadback();
-      const texture = framebuffer["colorTexture"];
-      const result = readback.readTextureSync(
-        texture,
-        x,
-        /**
-         * Origin is at lower-left corner. Width / height is already multiplied by dpr.
-         * WebGPU needs flipY
-         */
-        this.viewportOrigin === ViewportOrigin.LOWER_LEFT ? y : this.height - y,
-        width,
-        height,
-        new Uint8Array(width * height * 4)
-      );
-      if (this.viewportOrigin !== ViewportOrigin.LOWER_LEFT) {
-        for (let j = 0; j < result.length; j += 4) {
-          const t = result[j];
-          result[j] = result[j + 2];
-          result[j + 2] = t;
-        }
-      }
-      readback.destroy();
-      return result;
-    };
-    this.readPixelsAsync = (options) => __async(this, null, function* () {
-      const { framebuffer, x, y, width, height } = options;
-      const readback = this.device.createReadback();
-      const texture = framebuffer["colorTexture"];
-      const result = yield readback.readTexture(
-        texture,
-        x,
-        /**
-         * Origin is at lower-left corner. Width / height is already multiplied by dpr.
-         * WebGPU needs flipY
-         */
-        this.viewportOrigin === ViewportOrigin.LOWER_LEFT ? y : this.height - y,
-        width,
-        height,
-        new Uint8Array(width * height * 4)
-      );
-      if (this.viewportOrigin !== ViewportOrigin.LOWER_LEFT) {
-        for (let j = 0; j < result.length; j += 4) {
-          const t = result[j];
-          result[j] = result[j + 2];
-          result[j + 2] = t;
-        }
-      }
-      readback.destroy();
-      return result;
-    });
-    this.getViewportSize = () => {
-      return {
-        width: this.width,
-        height: this.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();
-      this.renderCache.destroy();
-    };
-  }
-  init(canvas, cfg) {
-    return __async(this, null, function* () {
-      const { enableWebGPU, shaderCompilerPath, antialias } = cfg;
-      this.canvas = canvas;
-      const deviceContribution = enableWebGPU ? new WebGPUDeviceContribution({
-        shaderCompilerPath
-      }) : new WebGLDeviceContribution({
-        // Use WebGL2 first and downgrade to WebGL1 if WebGL2 is not supported.
-        targets: ["webgl2", "webgl1"],
-        antialias,
-        onContextLost(e) {
-          console.warn("context lost", e);
-        },
-        onContextCreationError(e) {
-          console.warn("context creation error", e);
-        },
-        onContextRestored(e) {
-          console.warn("context restored", e);
-        }
-      });
-      const swapChain = yield deviceContribution.createSwapChain(canvas);
-      swapChain.configureSwapChain(canvas.width, canvas.height);
-      this.device = swapChain.getDevice();
-      this.swapChain = swapChain;
-      this.renderCache = new RenderCache(this.device);
-      this.currentFramebuffer = null;
-      this.viewportOrigin = this.device.queryVendorInfo().viewportOrigin;
-      const gl = this.device["gl"];
-      this.extensionObject = {
-        // @ts-ignore
-        OES_texture_float: !isWebGL2(gl) && this.device["OES_texture_float"]
-      };
-      this.createMainColorDepthRT(canvas.width, canvas.height);
-    });
-  }
-  createMainColorDepthRT(width, height) {
-    if (this.mainColorRT) {
-      this.mainColorRT.destroy();
-    }
-    if (this.mainDepthRT) {
-      this.mainDepthRT.destroy();
-    }
-    this.mainColorRT = this.device.createRenderTargetFromTexture(
-      this.device.createTexture({
-        format: Format.U8_RGBA_RT,
-        width,
-        height,
-        usage: TextureUsage.RENDER_TARGET
-      })
-    );
-    this.mainDepthRT = this.device.createRenderTargetFromTexture(
-      this.device.createTexture({
-        format: Format.D24_S8,
-        width,
-        height,
-        usage: TextureUsage.RENDER_TARGET
-      })
-    );
-  }
-  beginFrame() {
-    this.device.beginFrame();
-    const { currentFramebuffer, swapChain, mainColorRT, mainDepthRT } = this;
-    const colorAttachment = currentFramebuffer ? currentFramebuffer["colorRenderTarget"] : mainColorRT;
-    const colorResolveTo = currentFramebuffer ? null : swapChain.getOnscreenTexture();
-    const depthStencilAttachment = currentFramebuffer ? currentFramebuffer["depthRenderTarget"] : mainDepthRT;
-    const { color = [0, 0, 0, 0], depth = 1, stencil = 0 } = (
-      // @ts-ignore
-      (currentFramebuffer == null ? void 0 : currentFramebuffer.clearOptions) || {}
-    );
-    const colorClearColor = colorAttachment ? colorNewFromRGBA(color[0] * 255, color[1] * 255, color[2] * 255, color[3]) : TransparentBlack;
-    const depthClearValue = depthStencilAttachment ? depth : void 0;
-    const stencilClearValue = depthStencilAttachment ? stencil : void 0;
-    const renderPass = this.device.createRenderPass({
-      colorAttachment: [colorAttachment],
-      colorResolveTo: [colorResolveTo],
-      colorClearColor: [colorClearColor],
-      // colorStore: [!!currentFramebuffer],
-      colorStore: [true],
-      depthStencilAttachment,
-      depthClearValue,
-      stencilClearValue
-    });
-    this.renderPass = renderPass;
-  }
-  endFrame() {
-    this.device.submitPass(this.renderPass);
-    this.device.endFrame();
-  }
-  getPointSizeRange() {
-    const gl = this.device["gl"];
-    return gl.getParameter(gl.ALIASED_POINT_SIZE_RANGE);
-  }
-  testExtension(name) {
-    return !!this.getGLContext().getExtension(name);
-  }
-  // TODO: 临时方法
-  setState() {
-    const gl = this.getGLContext();
-    if (gl) {
-      gl.disable(gl.CULL_FACE);
-      gl.blendEquation(gl.FUNC_ADD);
-      gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
-    }
-  }
-  setBaseState() {
-    const gl = this.getGLContext();
-    if (gl) {
-      gl.disable(gl.CULL_FACE);
-      gl.blendEquation(gl.FUNC_ADD);
-      gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
-    }
-  }
-  setCustomLayerDefaults() {
-    const gl = this.getGLContext();
-    if (gl) {
-      gl.disable(gl.CULL_FACE);
-    }
-  }
-  setDirty(flag) {
-    this.isDirty = flag;
-  }
-  getDirty() {
-    return this.isDirty;
-  }
-};
-export {
-  DeviceRendererService as default
-};

package/es/device/utils/HashMap.d.ts

@@ -1,24 +0,0 @@
-export declare function hashCodeNumberUpdate(hash: number, v?: number): number;
-export declare function hashCodeNumberFinish(hash: number): number;
-export declare function nullHashFunc(): number;
-export type EqualFunc<K> = (a: K, b: K) => boolean;
-export type HashFunc<K> = (a: K) => number;
-declare class HashBucket<K, V> {
-    keys: K[];
-    values: V[];
-}
-export declare class HashMap<K, V> {
-    private keyEqualFunc;
-    private keyHashFunc;
-    buckets: Map<number, HashBucket<K, V>>;
-    constructor(keyEqualFunc: EqualFunc<K>, keyHashFunc: HashFunc<K>);
-    private findBucketIndex;
-    private findBucket;
-    get(k: K): V | null;
-    add(k: K, v: V): void;
-    delete(k: K): void;
-    clear(): void;
-    size(): number;
-    values(): IterableIterator<V>;
-}
-export {};

package/es/device/utils/HashMap.js

@@ -1,86 +0,0 @@
-// src/device/utils/HashMap.ts
-function hashCodeNumberUpdate(hash, v = 0) {
-  hash += v;
-  hash += hash << 10;
-  hash += hash >>> 6;
-  return hash >>> 0;
-}
-function hashCodeNumberFinish(hash) {
-  hash += hash << 3;
-  hash ^= hash >>> 11;
-  hash += hash << 15;
-  return hash >>> 0;
-}
-function nullHashFunc() {
-  return 0;
-}
-var HashBucket = class {
-  constructor() {
-    this.keys = [];
-    this.values = [];
-  }
-};
-var HashMap = class {
-  constructor(keyEqualFunc, keyHashFunc) {
-    this.keyEqualFunc = keyEqualFunc;
-    this.keyHashFunc = keyHashFunc;
-    this.buckets = /* @__PURE__ */ new Map();
-  }
-  findBucketIndex(bucket, k) {
-    for (let i = 0; i < bucket.keys.length; i++)
-      if (this.keyEqualFunc(k, bucket.keys[i]))
-        return i;
-    return -1;
-  }
-  findBucket(k) {
-    const bw = this.keyHashFunc(k);
-    return this.buckets.get(bw);
-  }
-  get(k) {
-    const bucket = this.findBucket(k);
-    if (bucket === void 0)
-      return null;
-    const bi = this.findBucketIndex(bucket, k);
-    if (bi < 0)
-      return null;
-    return bucket.values[bi];
-  }
-  add(k, v) {
-    const bw = this.keyHashFunc(k);
-    if (this.buckets.get(bw) === void 0)
-      this.buckets.set(bw, new HashBucket());
-    const bucket = this.buckets.get(bw);
-    bucket.keys.push(k);
-    bucket.values.push(v);
-  }
-  delete(k) {
-    const bucket = this.findBucket(k);
-    if (bucket === void 0)
-      return;
-    const bi = this.findBucketIndex(bucket, k);
-    if (bi === -1)
-      return;
-    bucket.keys.splice(bi, 1);
-    bucket.values.splice(bi, 1);
-  }
-  clear() {
-    this.buckets.clear();
-  }
-  size() {
-    let acc = 0;
-    for (const bucket of this.buckets.values())
-      acc += bucket.values.length;
-    return acc;
-  }
-  *values() {
-    for (const bucket of this.buckets.values())
-      for (let j = bucket.values.length - 1; j >= 0; j--)
-        yield bucket.values[j];
-  }
-};
-export {
-  HashMap,
-  hashCodeNumberFinish,
-  hashCodeNumberUpdate,
-  nullHashFunc
-};

package/es/device/utils/pipeline.d.ts

@@ -1 +0,0 @@
-export declare function pipelineEquals(): void;

package/es/device/utils/pipeline.js

@@ -1,6 +0,0 @@
-// src/device/utils/pipeline.ts
-function pipelineEquals() {
-}
-export {
-  pipelineEquals
-};

package/es/device/utils/typedarray.d.ts

@@ -1,7 +0,0 @@
-export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
-export declare function isTypedArray(x: any): x is TypedArray;
-/**
- * WebGPU does not support RGB texture, so we need to convert RGB to RGBA
- * @see https://github.com/antvis/L7/pull/2262
- */
-export declare function extend3ChannelsTo4(array: Float32Array, valueToInsert: number): Float32Array;

package/es/device/utils/typedarray.js

@@ -1,33 +0,0 @@
-// src/device/utils/typedarray.ts
-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;
-}
-function extend3ChannelsTo4(array, valueToInsert) {
-  const originalLength = array.length;
-  const insertCount = Math.ceil(originalLength / 3);
-  const newLength = originalLength + insertCount;
-  const newArray = new Float32Array(newLength);
-  for (let i = 0; i < newLength; i += 4) {
-    newArray[i] = array[i / 4 * 3];
-    newArray[i + 1] = array[i / 4 * 3 + 1];
-    newArray[i + 2] = array[i / 4 * 3 + 2];
-    newArray[i + 3] = valueToInsert;
-  }
-  return newArray;
-}
-export {
-  extend3ChannelsTo4,
-  isTypedArray
-};

package/es/device/utils/webgl.d.ts

@@ -1 +0,0 @@
-export declare function isWebGL2(gl: WebGL2RenderingContext | WebGLRenderingContext): gl is WebGL2RenderingContext;

package/es/device/utils/webgl.js

@@ -1,10 +0,0 @@
-// src/device/utils/webgl.ts
-function isWebGL2(gl) {
-  if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
-    return true;
-  }
-  return Boolean(gl && gl._version === 2);
-}
-export {
-  isWebGL2
-};

package/es/index.d.ts

@@ -1,3 +0,0 @@
-import DeviceRendererService from './device';
-import ReglRendererService from './regl';
-export { DeviceRendererService, ReglRendererService };

package/es/index.js

@@ -1,7 +0,0 @@
-// src/index.ts
-import DeviceRendererService from "./device";
-import ReglRendererService from "./regl";
-export {
-  DeviceRendererService,
-  ReglRendererService
-};