@antv/l7-renderer 2.25.5 → 2.25.7

package/lib/device/constants.d.ts

@@ -1,35 +0,0 @@
-import { AddressMode, BlendFactor, BlendMode, BufferFrequencyHint, CompareFunction, CullMode, Format, PrimitiveTopology, StencilOp } from '@antv/g-device-api';
-import type { TypedArray } from './utils/typedarray';
-export declare const typedArrayCtorMap: {
-    [key: string]: new (data: number[]) => TypedArray;
-};
-export declare const primitiveMap: {
-    [key: string]: PrimitiveTopology;
-};
-export declare const sizeFormatMap: {
-    [key: number]: Format;
-};
-export declare const hintMap: {
-    [key: string]: BufferFrequencyHint;
-};
-export declare const wrapModeMap: {
-    [key: string]: AddressMode;
-};
-export declare const depthFuncMap: {
-    [key: string]: CompareFunction;
-};
-export declare const cullFaceMap: {
-    [key: string]: CullMode;
-};
-export declare const blendEquationMap: {
-    [key: string]: BlendMode;
-};
-export declare const blendFuncMap: {
-    [key: string]: BlendFactor;
-};
-export declare const stencilOpMap: {
-    [key: string]: StencilOp;
-};
-export declare const stencilFuncMap: {
-    [key: string]: CompareFunction;
-};

package/lib/device/constants.js

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

package/lib/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/lib/device/index.js

@@ -1,332 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-
-// src/device/index.ts
-var device_exports = {};
-__export(device_exports, {
-  default: () => DeviceRendererService
-});
-module.exports = __toCommonJS(device_exports);
-var import_g_device_api = require("@antv/g-device-api");
-var import_l7_utils = require("@antv/l7-utils");
-var import_DeviceAttribute = __toESM(require("./DeviceAttribute"));
-var import_DeviceBuffer = __toESM(require("./DeviceBuffer"));
-var import_DeviceCache = require("./DeviceCache");
-var import_DeviceElements = __toESM(require("./DeviceElements"));
-var import_DeviceFramebuffer = __toESM(require("./DeviceFramebuffer"));
-var import_DeviceModel = __toESM(require("./DeviceModel"));
-var import_DeviceTexture2D = __toESM(require("./DeviceTexture2D"));
-var import_webgl = require("./utils/webgl");
-var { isUndefined } = import_l7_utils.lodashUtil;
-var DeviceRendererService = class {
-  constructor() {
-    this.uniformBuffers = [];
-    this.queryVerdorInfo = () => {
-      return this.device.queryVendorInfo().platformString;
-    };
-    this.createModel = (options) => new import_DeviceModel.default(this.device, options, this);
-    this.createAttribute = (options) => new import_DeviceAttribute.default(this.device, options);
-    this.createBuffer = (options) => new import_DeviceBuffer.default(this.device, options);
-    this.createElements = (options) => new import_DeviceElements.default(this.device, options);
-    this.createTexture2D = (options) => new import_DeviceTexture2D.default(this.device, options);
-    this.createFramebuffer = (options) => new import_DeviceFramebuffer.default(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 === import_g_device_api.ViewportOrigin.LOWER_LEFT ? y : this.height - y,
-        width,
-        height,
-        new Uint8Array(width * height * 4)
-      );
-      if (this.viewportOrigin !== import_g_device_api.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 === import_g_device_api.ViewportOrigin.LOWER_LEFT ? y : this.height - y,
-        width,
-        height,
-        new Uint8Array(width * height * 4)
-      );
-      if (this.viewportOrigin !== import_g_device_api.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 import_g_device_api.WebGPUDeviceContribution({
-        shaderCompilerPath
-      }) : new import_g_device_api.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 import_DeviceCache.RenderCache(this.device);
-      this.currentFramebuffer = null;
-      this.viewportOrigin = this.device.queryVendorInfo().viewportOrigin;
-      const gl = this.device["gl"];
-      this.extensionObject = {
-        // @ts-ignore
-        OES_texture_float: !(0, import_webgl.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: import_g_device_api.Format.U8_RGBA_RT,
-        width,
-        height,
-        usage: import_g_device_api.TextureUsage.RENDER_TARGET
-      })
-    );
-    this.mainDepthRT = this.device.createRenderTargetFromTexture(
-      this.device.createTexture({
-        format: import_g_device_api.Format.D24_S8,
-        width,
-        height,
-        usage: import_g_device_api.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 ? (0, import_g_device_api.colorNewFromRGBA)(color[0] * 255, color[1] * 255, color[2] * 255, color[3]) : import_g_device_api.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;
-  }
-};

package/lib/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 {};