@antv/l7-renderer 2.25.7 → 2.25.10

package/lib/device/constants.d.ts

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,141 @@
+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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,332 @@
+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

@@ -0,0 +1,24 @@
+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 {};