@antv/l7-renderer 2.25.7 → 2.25.9

package/es/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/es/device/DeviceAttribute.js

@@ -0,0 +1,30 @@
+// src/device/DeviceAttribute.ts
+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();
+  }
+};
+export {
+  DeviceAttribute as default
+};

package/es/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/es/device/DeviceBuffer.js

@@ -0,0 +1,51 @@
+// src/device/DeviceBuffer.ts
+import { BufferUsage } from "@antv/g-device-api";
+import { gl } from "@antv/l7-core";
+import { hintMap, typedArrayCtorMap } from "./constants";
+import { isTypedArray } from "./utils/typedarray";
+var DeviceBuffer = class {
+  constructor(device, options) {
+    this.isDestroyed = false;
+    const { data, usage, type, isUBO, label } = options;
+    let typed;
+    if (isTypedArray(data)) {
+      typed = data;
+    } else {
+      typed = new typedArrayCtorMap[this.type || gl.FLOAT](data);
+    }
+    this.type = type;
+    this.size = typed.byteLength;
+    this.buffer = device.createBuffer({
+      viewOrSize: typed,
+      usage: isUBO ? BufferUsage.UNIFORM : BufferUsage.VERTEX,
+      hint: hintMap[usage || 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 (isTypedArray(data)) {
+      typed = data;
+    } else {
+      typed = new typedArrayCtorMap[this.type || gl.FLOAT](data);
+    }
+    this.buffer.setSubData(offset, new Uint8Array(typed.buffer));
+  }
+};
+export {
+  DeviceBuffer as default
+};

package/es/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;
+}

package/es/device/DeviceCache.js

@@ -0,0 +1,198 @@
+// src/device/DeviceCache.ts
+import {
+  TransparentBlack,
+  bindingsDescriptorCopy,
+  bindingsDescriptorEquals,
+  inputLayoutDescriptorCopy,
+  inputLayoutDescriptorEquals,
+  renderPipelineDescriptorCopy,
+  renderPipelineDescriptorEquals
+} from "@antv/g-device-api";
+import { HashMap, hashCodeNumberFinish, hashCodeNumberUpdate, nullHashFunc } from "./utils/HashMap";
+function blendStateHash(hash, a) {
+  hash = hashCodeNumberUpdate(hash, a.blendMode);
+  hash = hashCodeNumberUpdate(hash, a.blendSrcFactor);
+  hash = hashCodeNumberUpdate(hash, a.blendDstFactor);
+  return hash;
+}
+function attachmentStateHash(hash, a) {
+  hash = blendStateHash(hash, a.rgbBlendState);
+  hash = blendStateHash(hash, a.alphaBlendState);
+  hash = hashCodeNumberUpdate(hash, a.channelWriteMask);
+  return hash;
+}
+function colorHash(hash, a) {
+  hash = hashCodeNumberUpdate(hash, a.r << 24 | a.g << 16 | a.b << 8 | a.a);
+  return hash;
+}
+function megaStateDescriptorHash(hash, a) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  for (let i = 0; i < a.attachmentsState.length; i++)
+    hash = attachmentStateHash(hash, a.attachmentsState[i]);
+  hash = colorHash(hash, a.blendConstant || TransparentBlack);
+  hash = hashCodeNumberUpdate(hash, a.depthCompare);
+  hash = hashCodeNumberUpdate(hash, a.depthWrite ? 1 : 0);
+  hash = hashCodeNumberUpdate(hash, (_a = a.stencilFront) == null ? void 0 : _a.compare);
+  hash = hashCodeNumberUpdate(hash, (_b = a.stencilFront) == null ? void 0 : _b.passOp);
+  hash = hashCodeNumberUpdate(hash, (_c = a.stencilFront) == null ? void 0 : _c.failOp);
+  hash = hashCodeNumberUpdate(hash, (_d = a.stencilFront) == null ? void 0 : _d.depthFailOp);
+  hash = hashCodeNumberUpdate(hash, (_e = a.stencilBack) == null ? void 0 : _e.compare);
+  hash = hashCodeNumberUpdate(hash, (_f = a.stencilBack) == null ? void 0 : _f.passOp);
+  hash = hashCodeNumberUpdate(hash, (_g = a.stencilBack) == null ? void 0 : _g.failOp);
+  hash = hashCodeNumberUpdate(hash, (_h = a.stencilBack) == null ? void 0 : _h.depthFailOp);
+  hash = hashCodeNumberUpdate(hash, a.stencilWrite ? 1 : 0);
+  hash = hashCodeNumberUpdate(hash, a.cullMode);
+  hash = hashCodeNumberUpdate(hash, a.frontFace ? 1 : 0);
+  hash = hashCodeNumberUpdate(hash, a.polygonOffset ? 1 : 0);
+  return hash;
+}
+function renderPipelineDescriptorHash(a) {
+  let hash = 0;
+  hash = hashCodeNumberUpdate(hash, a.program.id);
+  if (a.inputLayout !== null)
+    hash = hashCodeNumberUpdate(hash, a.inputLayout.id);
+  hash = megaStateDescriptorHash(hash, a.megaStateDescriptor);
+  for (let i = 0; i < a.colorAttachmentFormats.length; i++)
+    hash = hashCodeNumberUpdate(hash, a.colorAttachmentFormats[i] || 0);
+  hash = hashCodeNumberUpdate(hash, a.depthStencilAttachmentFormat || 0);
+  return hashCodeNumberFinish(hash);
+}
+function bindingsDescriptorHash(a) {
+  let hash = 0;
+  if (a.samplerBindings) {
+    for (let i = 0; i < a.samplerBindings.length; i++) {
+      const binding = a.samplerBindings[i];
+      if (binding !== null && binding.texture !== null)
+        hash = hashCodeNumberUpdate(hash, binding.texture.id);
+    }
+  }
+  if (a.uniformBufferBindings) {
+    for (let i = 0; i < a.uniformBufferBindings.length; i++) {
+      const binding = a.uniformBufferBindings[i];
+      if (binding !== null && binding.buffer !== null) {
+        hash = hashCodeNumberUpdate(hash, binding.buffer.id);
+        hash = hashCodeNumberUpdate(hash, binding.binding);
+        hash = hashCodeNumberUpdate(hash, binding.offset);
+        hash = hashCodeNumberUpdate(hash, binding.size);
+      }
+    }
+  }
+  if (a.storageBufferBindings) {
+    for (let i = 0; i < a.storageBufferBindings.length; i++) {
+      const binding = a.storageBufferBindings[i];
+      if (binding !== null && binding.buffer !== null) {
+        hash = hashCodeNumberUpdate(hash, binding.buffer.id);
+        hash = hashCodeNumberUpdate(hash, binding.binding);
+        hash = hashCodeNumberUpdate(hash, binding.offset);
+        hash = hashCodeNumberUpdate(hash, binding.size);
+      }
+    }
+  }
+  if (a.storageTextureBindings) {
+    for (let i = 0; i < a.storageTextureBindings.length; i++) {
+      const binding = a.storageTextureBindings[i];
+      if (binding !== null && binding.texture !== null) {
+        hash = hashCodeNumberUpdate(hash, binding.texture.id);
+        hash = hashCodeNumberUpdate(hash, binding.binding);
+      }
+    }
+  }
+  return hashCodeNumberFinish(hash);
+}
+function programDescriptorEquals(a, b) {
+  var _a, _b, _c, _d;
+  return ((_a = a.vertex) == null ? void 0 : _a.glsl) === ((_b = b.vertex) == null ? void 0 : _b.glsl) && ((_c = a.fragment) == null ? void 0 : _c.glsl) === ((_d = b.fragment) == null ? void 0 : _d.glsl);
+}
+function programDescriptorCopy(a) {
+  var _a, _b;
+  return {
+    vertex: {
+      glsl: (_a = a.vertex) == null ? void 0 : _a.glsl
+    },
+    fragment: {
+      glsl: (_b = a.fragment) == null ? void 0 : _b.glsl
+    }
+  };
+}
+var RenderCache = class {
+  constructor(device) {
+    this.device = device;
+    this.bindingsCache = new HashMap(
+      bindingsDescriptorEquals,
+      bindingsDescriptorHash
+    );
+    this.renderPipelinesCache = new HashMap(
+      renderPipelineDescriptorEquals,
+      renderPipelineDescriptorHash
+    );
+    this.inputLayoutsCache = new HashMap(
+      inputLayoutDescriptorEquals,
+      nullHashFunc
+    );
+    this.programCache = new HashMap(
+      programDescriptorEquals,
+      nullHashFunc
+    );
+  }
+  createBindings(descriptor) {
+    var _a;
+    let bindings = this.bindingsCache.get(descriptor);
+    if (bindings === null) {
+      const descriptorCopy = bindingsDescriptorCopy(descriptor);
+      descriptorCopy.uniformBufferBindings = (_a = descriptorCopy.uniformBufferBindings) == null ? void 0 : _a.filter(
+        ({ size }) => size && size > 0
+      );
+      bindings = this.device.createBindings(descriptorCopy);
+      this.bindingsCache.add(descriptorCopy, bindings);
+    }
+    return bindings;
+  }
+  createRenderPipeline(descriptor) {
+    let renderPipeline = this.renderPipelinesCache.get(descriptor);
+    if (renderPipeline === null) {
+      const descriptorCopy = renderPipelineDescriptorCopy(descriptor);
+      descriptorCopy.colorAttachmentFormats = descriptorCopy.colorAttachmentFormats.filter(
+        (f) => f
+      );
+      renderPipeline = this.device.createRenderPipeline(descriptorCopy);
+      this.renderPipelinesCache.add(descriptorCopy, renderPipeline);
+    }
+    return renderPipeline;
+  }
+  createInputLayout(descriptor) {
+    descriptor.vertexBufferDescriptors = descriptor.vertexBufferDescriptors.filter((d) => !!d);
+    let inputLayout = this.inputLayoutsCache.get(descriptor);
+    if (inputLayout === null) {
+      const descriptorCopy = inputLayoutDescriptorCopy(descriptor);
+      inputLayout = this.device.createInputLayout(descriptorCopy);
+      this.inputLayoutsCache.add(descriptorCopy, inputLayout);
+    }
+    return inputLayout;
+  }
+  createProgram(descriptor) {
+    let program = this.programCache.get(descriptor);
+    if (program === null) {
+      const descriptorCopy = programDescriptorCopy(descriptor);
+      program = this.device.createProgram(descriptor);
+      this.programCache.add(descriptorCopy, program);
+    }
+    return program;
+  }
+  destroy() {
+    for (const bindings of this.bindingsCache.values())
+      bindings.destroy();
+    for (const renderPipeline of this.renderPipelinesCache.values())
+      renderPipeline.destroy();
+    for (const inputLayout of this.inputLayoutsCache.values())
+      inputLayout.destroy();
+    for (const program of this.programCache.values())
+      program.destroy();
+    this.bindingsCache.clear();
+    this.renderPipelinesCache.clear();
+    this.inputLayoutsCache.clear();
+    this.programCache.clear();
+  }
+};
+export {
+  RenderCache
+};

package/es/device/DeviceElements.d.ts

@@ -0,0 +1,13 @@
+import type { Buffer, Device } from '@antv/g-device-api';
+import type { IElements, IElementsInitializationOptions } from '@antv/l7-core';
+export default class DeviceElements implements IElements {
+    private indexBuffer;
+    private type;
+    private count;
+    constructor(device: Device, options: IElementsInitializationOptions);
+    get(): Buffer;
+    subData({ data, }: {
+        data: number[] | number[][] | Uint8Array | Uint16Array | Uint32Array;
+    }): void;
+    destroy(): void;
+}

package/es/device/DeviceElements.js

@@ -0,0 +1,42 @@
+// src/device/DeviceElements.ts
+import { BufferUsage } from "@antv/g-device-api";
+import { gl } from "@antv/l7-core";
+import { typedArrayCtorMap } from "./constants";
+import { isTypedArray } from "./utils/typedarray";
+var DeviceElements = class {
+  constructor(device, options) {
+    const { data, type, count = 0 } = options;
+    let typed;
+    if (isTypedArray(data)) {
+      typed = data;
+    } else {
+      typed = new typedArrayCtorMap[this.type || gl.UNSIGNED_INT](data);
+    }
+    this.type = type;
+    this.count = count;
+    this.indexBuffer = device.createBuffer({
+      viewOrSize: typed,
+      usage: BufferUsage.INDEX
+    });
+  }
+  get() {
+    return this.indexBuffer;
+  }
+  subData({
+    data
+  }) {
+    let typed;
+    if (isTypedArray(data)) {
+      typed = data;
+    } else {
+      typed = new typedArrayCtorMap[this.type || gl.UNSIGNED_INT](data);
+    }
+    this.indexBuffer.setSubData(0, new Uint8Array(typed.buffer));
+  }
+  destroy() {
+    this.indexBuffer.destroy();
+  }
+};
+export {
+  DeviceElements as default
+};

package/es/device/DeviceFramebuffer.d.ts

@@ -0,0 +1,24 @@
+import type { Device, RenderTarget, Texture } from '@antv/g-device-api';
+import type { IFramebuffer, IFramebufferInitializationOptions } from '@antv/l7-core';
+/**
+ * Contains 2 render targets: color and depth.
+ */
+export default class DeviceFramebuffer implements IFramebuffer {
+    private device;
+    private options;
+    private colorRenderTarget;
+    colorTexture: Texture;
+    private depthRenderTarget;
+    private depthTexture;
+    private width;
+    private height;
+    constructor(device: Device, options: IFramebufferInitializationOptions);
+    private createColorRenderTarget;
+    private createDepthRenderTarget;
+    get(): RenderTarget;
+    destroy(): void;
+    resize({ width, height }: {
+        width: number;
+        height: number;
+    }): void;
+}

package/es/device/DeviceFramebuffer.js

@@ -0,0 +1,81 @@
+// src/device/DeviceFramebuffer.ts
+import { Format, TextureUsage } from "@antv/g-device-api";
+import { isTexture2D } from "./DeviceTexture2D";
+var DeviceFramebuffer = class {
+  constructor(device, options) {
+    this.device = device;
+    this.options = options;
+    this.createColorRenderTarget();
+    this.createDepthRenderTarget();
+  }
+  createColorRenderTarget(resize = false) {
+    const { width, height, color } = this.options;
+    if (color) {
+      if (isTexture2D(color)) {
+        if (resize) {
+          color.resize({ width, height });
+        }
+        this.colorTexture = color.get();
+        this.colorRenderTarget = this.device.createRenderTargetFromTexture(this.colorTexture);
+        this.width = color["width"];
+        this.height = color["height"];
+      } else if (width && height) {
+        this.colorTexture = this.device.createTexture({
+          format: Format.U8_RGBA_RT,
+          usage: TextureUsage.RENDER_TARGET,
+          width,
+          height
+        });
+        this.colorRenderTarget = this.device.createRenderTargetFromTexture(this.colorTexture);
+        this.width = width;
+        this.height = height;
+      }
+    }
+  }
+  createDepthRenderTarget(resize = false) {
+    const { width, height, depth } = this.options;
+    if (depth) {
+      if (isTexture2D(depth)) {
+        if (resize) {
+          depth.resize({ width, height });
+        }
+        this.depthTexture = depth.get();
+        this.depthRenderTarget = this.device.createRenderTargetFromTexture(this.depthTexture);
+        this.width = depth["width"];
+        this.height = depth["height"];
+      } else if (width && height) {
+        this.depthTexture = this.device.createTexture({
+          format: Format.D24_S8,
+          usage: TextureUsage.RENDER_TARGET,
+          width,
+          height
+        });
+        this.depthRenderTarget = this.device.createRenderTargetFromTexture(this.depthTexture);
+        this.width = width;
+        this.height = height;
+      }
+    }
+  }
+  get() {
+    return this.colorRenderTarget;
+  }
+  destroy() {
+    var _a, _b;
+    (_a = this.colorRenderTarget) == null ? void 0 : _a.destroy();
+    (_b = this.depthRenderTarget) == null ? void 0 : _b.destroy();
+  }
+  resize({ width, height }) {
+    if (this.width !== width || this.height !== height) {
+      this.destroy();
+      this.colorTexture.destroyed = true;
+      this.depthTexture.destroyed = true;
+      this.options.width = width;
+      this.options.height = height;
+      this.createColorRenderTarget(true);
+      this.createDepthRenderTarget(true);
+    }
+  }
+};
+export {
+  DeviceFramebuffer as default
+};

package/es/device/DeviceModel.d.ts

@@ -0,0 +1,61 @@
+import type { Device } from '@antv/g-device-api';
+import type { IModel, IModelDrawOptions, IModelInitializationOptions, IUniform } from '@antv/l7-core';
+import type DeviceRendererService from '.';
+export default class DeviceModel implements IModel {
+    private device;
+    private options;
+    private service;
+    private destroyed;
+    private uniforms;
+    private program;
+    private inputLayout;
+    private pipeline;
+    private indexBuffer;
+    private vertexBuffers;
+    private bindings;
+    private pipelineCache;
+    private currentPipelineKey;
+    constructor(device: Device, options: IModelInitializationOptions, service: DeviceRendererService);
+    /**
+     * 生成 Pipeline 缓存键，用于判断是否需要重新创建 Pipeline
+     * 包含所有影响 Pipeline 创建的参数
+     * 注意：当 blend/stencil 禁用时，使用简化的 key 以避免创建重复 Pipeline
+     */
+    private getPipelineKey;
+    private createPipeline;
+    updateAttributesAndElements(): void;
+    /**
+     * No need to implement this method, you should update data on `Attribute` like this:
+     *
+     * @example
+     * ```ts
+     * attribute.updateBuffer({
+     *   data: [],
+     *   offset: 0,
+     * });
+     * ```
+     */
+    updateAttributes(): void;
+    addUniforms(uniforms: {
+        [key: string]: IUniform;
+    }): void;
+    draw(options: IModelDrawOptions, pick?: boolean): void;
+    destroy(): void;
+    private initDepthDrawParams;
+    private getBlendDrawParams;
+    /**
+     * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#stencil
+     */
+    private getStencilDrawParams;
+    /**
+     * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#culling
+     */
+    private initCullDrawParams;
+    /**
+     * 考虑结构体命名, eg:
+     * a: { b: 1 }  ->  'a.b'
+     * a: [ { b: 1 } ] -> 'a[0].b'
+     */
+    private extractUniforms;
+    private extractUniformsRecursively;
+}