@antv/l7-renderer 2.25.7 → 2.25.9

package/es/regl/constants.d.ts

@@ -0,0 +1,43 @@
+import type regl from 'regl';
+export declare const primitiveMap: {
+    [key: string]: 'points' | 'lines' | 'line loop' | 'line strip' | 'triangles' | 'triangle strip' | 'triangle fan';
+};
+export declare const usageMap: {
+    [key: string]: 'static' | 'dynamic' | 'stream';
+};
+export declare const dataTypeMap: {
+    [key: string]: 'int8' | 'int16' | 'int32' | 'uint8' | 'uint16' | 'uint32' | 'float';
+};
+export declare const formatMap: {
+    [key: string]: 'alpha' | 'luminance' | 'luminance alpha' | 'rgb' | 'rgba' | 'rgba4' | 'rgb5 a1' | 'rgb565' | 'depth' | 'depth stencil';
+};
+export declare const mipmapMap: {
+    [key: string]: 'dont care' | 'nice' | 'fast';
+};
+export declare const filterMap: {
+    [key: string]: 'nearest' | 'linear' | 'mipmap' | 'nearest mipmap linear' | 'linear mipmap nearest' | 'nearest mipmap nearest';
+};
+export declare const wrapModeMap: {
+    [key: string]: 'repeat' | 'clamp' | 'mirror';
+};
+export declare const colorSpaceMap: {
+    [key: string]: 'none' | 'browser';
+};
+export declare const depthFuncMap: {
+    [key: string]: 'never' | 'always' | 'less' | 'lequal' | 'greater' | 'gequal' | 'equal' | 'notequal';
+};
+export declare const blendEquationMap: {
+    [key: string]: regl.BlendingEquation;
+};
+export declare const blendFuncMap: {
+    [key: string]: regl.BlendingFunction;
+};
+export declare const stencilFuncMap: {
+    [key: string]: regl.ComparisonOperatorType;
+};
+export declare const stencilOpMap: {
+    [key: string]: regl.StencilOperationType;
+};
+export declare const cullFaceMap: {
+    [key: string]: regl.FaceOrientationType;
+};

package/es/regl/constants.js

@@ -0,0 +1,133 @@
+// src/regl/constants.ts
+import { gl } from "@antv/l7-core";
+var primitiveMap = {
+  [gl.POINTS]: "points",
+  [gl.LINES]: "lines",
+  [gl.LINE_LOOP]: "line loop",
+  [gl.LINE_STRIP]: "line strip",
+  [gl.TRIANGLES]: "triangles",
+  [gl.TRIANGLE_FAN]: "triangle fan",
+  [gl.TRIANGLE_STRIP]: "triangle strip"
+};
+var usageMap = {
+  [gl.STATIC_DRAW]: "static",
+  [gl.DYNAMIC_DRAW]: "dynamic",
+  [gl.STREAM_DRAW]: "stream"
+};
+var dataTypeMap = {
+  [gl.BYTE]: "int8",
+  // [gl.UNSIGNED_INT]: 'int16',
+  [gl.INT]: "int32",
+  [gl.UNSIGNED_BYTE]: "uint8",
+  [gl.UNSIGNED_SHORT]: "uint16",
+  [gl.UNSIGNED_INT]: "uint32",
+  [gl.FLOAT]: "float"
+};
+var formatMap = {
+  [gl.ALPHA]: "alpha",
+  [gl.LUMINANCE]: "luminance",
+  [gl.LUMINANCE_ALPHA]: "luminance alpha",
+  [gl.RGB]: "rgb",
+  [gl.RGBA]: "rgba",
+  [gl.RGBA4]: "rgba4",
+  [gl.RGB5_A1]: "rgb5 a1",
+  [gl.RGB565]: "rgb565",
+  [gl.DEPTH_COMPONENT]: "depth",
+  [gl.DEPTH_STENCIL]: "depth stencil"
+};
+var mipmapMap = {
+  [gl.DONT_CARE]: "dont care",
+  [gl.NICEST]: "nice",
+  [gl.FASTEST]: "fast"
+};
+var filterMap = {
+  [gl.NEAREST]: "nearest",
+  [gl.LINEAR]: "linear",
+  [gl.LINEAR_MIPMAP_LINEAR]: "mipmap",
+  [gl.NEAREST_MIPMAP_LINEAR]: "nearest mipmap linear",
+  [gl.LINEAR_MIPMAP_NEAREST]: "linear mipmap nearest",
+  [gl.NEAREST_MIPMAP_NEAREST]: "nearest mipmap nearest"
+};
+var wrapModeMap = {
+  [gl.REPEAT]: "repeat",
+  [gl.CLAMP_TO_EDGE]: "clamp",
+  [gl.MIRRORED_REPEAT]: "mirror"
+};
+var colorSpaceMap = {
+  [gl.NONE]: "none",
+  [gl.BROWSER_DEFAULT_WEBGL]: "browser"
+};
+var depthFuncMap = {
+  [gl.NEVER]: "never",
+  [gl.ALWAYS]: "always",
+  [gl.LESS]: "less",
+  [gl.LEQUAL]: "lequal",
+  [gl.GREATER]: "greater",
+  [gl.GEQUAL]: "gequal",
+  [gl.EQUAL]: "equal",
+  [gl.NOTEQUAL]: "notequal"
+};
+var blendEquationMap = {
+  [gl.FUNC_ADD]: "add",
+  [gl.MIN_EXT]: "min",
+  [gl.MAX_EXT]: "max",
+  [gl.FUNC_SUBTRACT]: "subtract",
+  [gl.FUNC_REVERSE_SUBTRACT]: "reverse subtract"
+};
+var blendFuncMap = {
+  [gl.ZERO]: "zero",
+  [gl.ONE]: "one",
+  [gl.SRC_COLOR]: "src color",
+  [gl.ONE_MINUS_SRC_COLOR]: "one minus src color",
+  [gl.SRC_ALPHA]: "src alpha",
+  [gl.ONE_MINUS_SRC_ALPHA]: "one minus src alpha",
+  [gl.DST_COLOR]: "dst color",
+  [gl.ONE_MINUS_DST_COLOR]: "one minus dst color",
+  [gl.DST_ALPHA]: "dst alpha",
+  [gl.ONE_MINUS_DST_ALPHA]: "one minus dst alpha",
+  [gl.CONSTANT_COLOR]: "constant color",
+  [gl.ONE_MINUS_CONSTANT_COLOR]: "one minus constant color",
+  [gl.CONSTANT_ALPHA]: "constant alpha",
+  [gl.ONE_MINUS_CONSTANT_ALPHA]: "one minus constant alpha",
+  [gl.SRC_ALPHA_SATURATE]: "src alpha saturate"
+};
+var stencilFuncMap = {
+  [gl.NEVER]: "never",
+  [gl.ALWAYS]: "always",
+  [gl.LESS]: "less",
+  [gl.LEQUAL]: "lequal",
+  [gl.GREATER]: "greater",
+  [gl.GEQUAL]: "gequal",
+  [gl.EQUAL]: "equal",
+  [gl.NOTEQUAL]: "notequal"
+};
+var stencilOpMap = {
+  [gl.ZERO]: "zero",
+  [gl.KEEP]: "keep",
+  [gl.REPLACE]: "replace",
+  [gl.INVERT]: "invert",
+  [gl.INCR]: "increment",
+  [gl.DECR]: "decrement",
+  [gl.INCR_WRAP]: "increment wrap",
+  [gl.DECR_WRAP]: "decrement wrap"
+};
+var cullFaceMap = {
+  [gl.FRONT]: "front",
+  [gl.BACK]: "back"
+};
+export {
+  blendEquationMap,
+  blendFuncMap,
+  colorSpaceMap,
+  cullFaceMap,
+  dataTypeMap,
+  depthFuncMap,
+  filterMap,
+  formatMap,
+  mipmapMap,
+  primitiveMap,
+  stencilFuncMap,
+  stencilOpMap,
+  usageMap,
+  wrapModeMap
+};

package/es/regl/index.d.ts

@@ -0,0 +1,56 @@
+/**
+ * render w/ regl
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md
+ */
+import type { IAttribute, IAttributeInitializationOptions, IBuffer, IBufferInitializationOptions, IClearOptions, IElements, IElementsInitializationOptions, IExtensions, IFramebuffer, IFramebufferInitializationOptions, IModel, IModelInitializationOptions, IReadPixelsOptions, IRenderConfig, IRendererService, ITexture2D, ITexture2DInitializationOptions } from '@antv/l7-core';
+import regl from 'regl';
+import ReglFramebuffer from './ReglFramebuffer';
+/**
+ * regl renderer
+ */
+export default class ReglRendererService implements IRendererService {
+    uniformBuffers: IBuffer[];
+    extensionObject: IExtensions;
+    private gl;
+    private $container;
+    private canvas;
+    private width;
+    private height;
+    private isDirty;
+    queryVerdorInfo: () => string;
+    init(canvas: HTMLCanvasElement, cfg: IRenderConfig, gl?: regl.Regl): Promise<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) => ReglFramebuffer;
+    useFramebuffer: (framebuffer: IFramebuffer | null, drawCommands: () => void) => void;
+    useFramebufferAsync: (framebuffer: IFramebuffer | null, drawCommands: () => Promise<void>) => Promise<void>;
+    clear: (options: IClearOptions) => void;
+    viewport: ({ x, y, 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;
+    beginFrame(): void;
+    endFrame(): void;
+}

package/es/regl/index.js

@@ -0,0 +1,227 @@
+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/regl/index.ts
+import regl from "regl";
+import ReglAttribute from "./ReglAttribute";
+import ReglBuffer from "./ReglBuffer";
+import ReglElements from "./ReglElements";
+import ReglFramebuffer from "./ReglFramebuffer";
+import ReglModel from "./ReglModel";
+import ReglTexture2D from "./ReglTexture2D";
+var ReglRendererService = class {
+  constructor() {
+    this.uniformBuffers = [];
+    this.queryVerdorInfo = () => {
+      return "WebGL1";
+    };
+    this.createModel = (options) => new ReglModel(this.gl, options);
+    this.createAttribute = (options) => new ReglAttribute(this.gl, options);
+    this.createBuffer = (options) => new ReglBuffer(this.gl, options);
+    this.createElements = (options) => new ReglElements(this.gl, options);
+    this.createTexture2D = (options) => new ReglTexture2D(this.gl, options);
+    this.createFramebuffer = (options) => new ReglFramebuffer(this.gl, options);
+    this.useFramebuffer = (framebuffer, drawCommands) => {
+      this.gl({
+        framebuffer: framebuffer ? framebuffer.get() : null
+      })(drawCommands);
+    };
+    this.useFramebufferAsync = (framebuffer, drawCommands) => __async(this, null, function* () {
+      this.gl({
+        framebuffer: framebuffer ? framebuffer.get() : null
+      })(drawCommands);
+    });
+    this.clear = (options) => {
+      var _a;
+      const { color, depth, stencil, framebuffer = null } = options;
+      const reglClearOptions = {
+        color,
+        depth,
+        stencil
+      };
+      reglClearOptions.framebuffer = framebuffer === null ? framebuffer : framebuffer.get();
+      (_a = this.gl) == null ? void 0 : _a.clear(reglClearOptions);
+    };
+    this.viewport = ({
+      x,
+      y,
+      width,
+      height
+    }) => {
+      this.gl._gl.viewport(x, y, width, height);
+      this.width = width;
+      this.height = height;
+      this.gl._refresh();
+    };
+    this.readPixels = (options) => {
+      const { framebuffer, x, y, width, height } = options;
+      const readPixelsOptions = {
+        x,
+        y,
+        width,
+        height
+      };
+      if (framebuffer) {
+        readPixelsOptions.framebuffer = framebuffer.get();
+      }
+      return this.gl.read(readPixelsOptions);
+    };
+    this.readPixelsAsync = (options) => __async(this, null, function* () {
+      return this.readPixels(options);
+    });
+    this.getViewportSize = () => {
+      return {
+        width: this.gl._gl.drawingBufferWidth,
+        height: this.gl._gl.drawingBufferHeight
+      };
+    };
+    this.getContainer = () => {
+      var _a;
+      return (_a = this.canvas) == null ? void 0 : _a.parentElement;
+    };
+    this.getCanvas = () => {
+      return this.canvas;
+    };
+    this.getGLContext = () => {
+      return this.gl._gl;
+    };
+    this.destroy = () => {
+      var _a, _b, _c;
+      this.canvas = null;
+      (_c = (_b = (_a = this.gl) == null ? void 0 : _a._gl) == null ? void 0 : _b.getExtension("WEBGL_lose_context")) == null ? void 0 : _c.loseContext();
+      this.gl.destroy();
+      this.gl = null;
+    };
+  }
+  init(canvas, cfg, gl) {
+    return __async(this, null, function* () {
+      this.canvas = canvas;
+      if (gl) {
+        this.gl = gl;
+      } else {
+        this.gl = yield new Promise((resolve, reject) => {
+          regl({
+            canvas: this.canvas,
+            attributes: {
+              alpha: true,
+              // use TAA instead of MSAA
+              // @see https://www.khronos.org/registry/webgl/specs/1.0/#5.2.1
+              antialias: cfg.antialias,
+              premultipliedAlpha: true,
+              preserveDrawingBuffer: cfg.preserveDrawingBuffer,
+              stencil: cfg.stencil
+            },
+            // TODO: use extensions
+            extensions: [
+              "OES_element_index_uint",
+              "OES_standard_derivatives",
+              // wireframe
+              "ANGLE_instanced_arrays"
+              // VSM shadow map
+            ],
+            optionalExtensions: [
+              "oes_texture_float_linear",
+              "OES_texture_float",
+              "EXT_texture_filter_anisotropic",
+              "EXT_blend_minmax",
+              "WEBGL_depth_texture",
+              "WEBGL_lose_context"
+            ],
+            profile: true,
+            onDone: (err, r) => {
+              if (err || !r) {
+                reject(err);
+              }
+              resolve(r);
+            }
+          });
+        });
+      }
+      this.extensionObject = {
+        OES_texture_float: this.testExtension("OES_texture_float")
+      };
+    });
+  }
+  getPointSizeRange() {
+    return this.gl._gl.getParameter(this.gl._gl.ALIASED_POINT_SIZE_RANGE);
+  }
+  testExtension(name) {
+    return !!this.getGLContext().getExtension(name);
+  }
+  // TODO: 临时方法
+  setState() {
+    this.gl({
+      cull: {
+        enable: false,
+        face: "back"
+      },
+      viewport: {
+        x: 0,
+        y: 0,
+        height: this.width,
+        width: this.height
+      },
+      blend: {
+        enable: true,
+        equation: "add"
+      },
+      framebuffer: null
+    });
+    this.gl._refresh();
+  }
+  setBaseState() {
+    this.gl({
+      cull: {
+        enable: false,
+        face: "back"
+      },
+      viewport: {
+        x: 0,
+        y: 0,
+        height: this.width,
+        width: this.height
+      },
+      blend: {
+        enable: false,
+        equation: "add"
+      },
+      framebuffer: null
+    });
+    this.gl._refresh();
+  }
+  setCustomLayerDefaults() {
+    const gl = this.getGLContext();
+    gl.disable(gl.CULL_FACE);
+  }
+  setDirty(flag) {
+    this.isDirty = flag;
+  }
+  getDirty() {
+    return this.isDirty;
+  }
+  beginFrame() {
+  }
+  endFrame() {
+  }
+};
+export {
+  ReglRendererService as default
+};

package/lib/device/DeviceAttribute.d.ts

@@ -0,0 +1,13 @@
+import type { Device } from '@antv/g-device-api';
+import type { IAttribute, IAttributeInitializationOptions, IBuffer } from '@antv/l7-core';
+export default class DeviceAttribute implements IAttribute {
+    private attribute;
+    private buffer;
+    constructor(device: Device, options: IAttributeInitializationOptions);
+    get(): IBuffer;
+    updateBuffer(options: {
+        data: number[] | number[][] | Uint8Array | Uint16Array | Uint32Array;
+        offset: number;
+    }): void;
+    destroy(): void;
+}

package/lib/device/DeviceAttribute.js

@@ -0,0 +1,50 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/device/DeviceAttribute.ts
+var DeviceAttribute_exports = {};
+__export(DeviceAttribute_exports, {
+  default: () => DeviceAttribute
+});
+module.exports = __toCommonJS(DeviceAttribute_exports);
+var DeviceAttribute = class {
+  constructor(device, options) {
+    const { buffer, offset, stride, normalized, size, divisor, shaderLocation } = options;
+    this.buffer = buffer;
+    this.attribute = {
+      shaderLocation,
+      buffer: buffer.get(),
+      offset: offset || 0,
+      stride: stride || 0,
+      normalized: normalized || false,
+      divisor: divisor || 0
+    };
+    if (size) {
+      this.attribute.size = size;
+    }
+  }
+  get() {
+    return this.buffer;
+  }
+  updateBuffer(options) {
+    this.buffer.subData(options);
+  }
+  destroy() {
+    this.buffer.destroy();
+  }
+};

package/lib/device/DeviceBuffer.d.ts

@@ -0,0 +1,18 @@
+import type { Buffer, Device } from '@antv/g-device-api';
+import type { IBuffer, IBufferInitializationOptions } from '@antv/l7-core';
+/**
+ * Use Buffer from @antv/g-device-api
+ */
+export default class DeviceBuffer implements IBuffer {
+    private buffer;
+    private isDestroyed;
+    private type;
+    private size;
+    constructor(device: Device, options: IBufferInitializationOptions);
+    get(): Buffer;
+    destroy(): void;
+    subData({ data, offset, }: {
+        data: number[] | number[][] | Uint8Array | Uint16Array | Uint32Array;
+        offset: number;
+    }): void;
+}

package/lib/device/DeviceBuffer.js

@@ -0,0 +1,71 @@
+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/DeviceBuffer.ts
+var DeviceBuffer_exports = {};
+__export(DeviceBuffer_exports, {
+  default: () => DeviceBuffer
+});
+module.exports = __toCommonJS(DeviceBuffer_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");
+var DeviceBuffer = class {
+  constructor(device, options) {
+    this.isDestroyed = false;
+    const { data, usage, type, isUBO, label } = options;
+    let typed;
+    if ((0, import_typedarray.isTypedArray)(data)) {
+      typed = data;
+    } else {
+      typed = new import_constants.typedArrayCtorMap[this.type || import_l7_core.gl.FLOAT](data);
+    }
+    this.type = type;
+    this.size = typed.byteLength;
+    this.buffer = device.createBuffer({
+      viewOrSize: typed,
+      usage: isUBO ? import_g_device_api.BufferUsage.UNIFORM : import_g_device_api.BufferUsage.VERTEX,
+      hint: import_constants.hintMap[usage || import_l7_core.gl.STATIC_DRAW]
+    });
+    if (label) {
+      device.setResourceName(this.buffer, label);
+    }
+  }
+  get() {
+    return this.buffer;
+  }
+  destroy() {
+    if (!this.isDestroyed) {
+      this.buffer.destroy();
+    }
+    this.isDestroyed = true;
+  }
+  subData({
+    data,
+    offset
+  }) {
+    let typed;
+    if ((0, import_typedarray.isTypedArray)(data)) {
+      typed = data;
+    } else {
+      typed = new import_constants.typedArrayCtorMap[this.type || import_l7_core.gl.FLOAT](data);
+    }
+    this.buffer.setSubData(offset, new Uint8Array(typed.buffer));
+  }
+};

package/lib/device/DeviceCache.d.ts

@@ -0,0 +1,14 @@
+import type { Bindings, BindingsDescriptor, Device, InputLayout, InputLayoutDescriptor, Program, ProgramDescriptor, RenderPipeline, RenderPipelineDescriptor } from '@antv/g-device-api';
+export declare class RenderCache {
+    private device;
+    constructor(device: Device);
+    private bindingsCache;
+    private renderPipelinesCache;
+    private inputLayoutsCache;
+    private programCache;
+    createBindings(descriptor: BindingsDescriptor): Bindings;
+    createRenderPipeline(descriptor: RenderPipelineDescriptor): RenderPipeline;
+    createInputLayout(descriptor: InputLayoutDescriptor): InputLayout;
+    createProgram(descriptor: ProgramDescriptor): Program;
+    destroy(): void;
+}