@antv/l7-renderer 2.19.11 → 2.20.0

package/es/device/DeviceAttribute.d.ts

@@ -0,0 +1,13 @@
+import { Device } from '@antv/g-device-api';
+import { 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,44 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+var DeviceAttribute = /*#__PURE__*/function () {
+  function DeviceAttribute(device, options) {
+    _classCallCheck(this, DeviceAttribute);
+    var buffer = options.buffer,
+      offset = options.offset,
+      stride = options.stride,
+      normalized = options.normalized,
+      size = options.size,
+      divisor = options.divisor,
+      shaderLocation = options.shaderLocation;
+    this.buffer = buffer;
+    this.attribute = {
+      shaderLocation: shaderLocation,
+      buffer: buffer.get(),
+      offset: offset || 0,
+      stride: stride || 0,
+      normalized: normalized || false,
+      divisor: divisor || 0
+    };
+    if (size) {
+      this.attribute.size = size;
+    }
+  }
+  _createClass(DeviceAttribute, [{
+    key: "get",
+    value: function get() {
+      return this.buffer;
+    }
+  }, {
+    key: "updateBuffer",
+    value: function updateBuffer(options) {
+      this.buffer.subData(options);
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.buffer.destroy();
+    }
+  }]);
+  return DeviceAttribute;
+}();
+export { DeviceAttribute as default };

package/es/device/DeviceBuffer.d.ts

@@ -0,0 +1,18 @@
+import { Buffer, Device } from '@antv/g-device-api';
+import { 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,65 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { BufferUsage } from '@antv/g-device-api';
+import { gl } from '@antv/l7-core';
+import { hintMap, typedArrayCtorMap } from "./constants";
+import { isTypedArray } from "./utils/typedarray";
+
+/**
+ * Use Buffer from @antv/g-device-api
+ */
+var DeviceBuffer = /*#__PURE__*/function () {
+  function DeviceBuffer(device, options) {
+    _classCallCheck(this, DeviceBuffer);
+    _defineProperty(this, "isDestroyed", false);
+    var data = options.data,
+      usage = options.usage,
+      type = options.type,
+      isUBO = options.isUBO;
+    var typed;
+    if (isTypedArray(data)) {
+      typed = data;
+    } else {
+      typed = new typedArrayCtorMap[this.type || gl.FLOAT](data);
+    }
+    this.type = type;
+    this.size = typed.byteLength;
+
+    // @see https://www.npmjs.com/package/@antv/g-device-api#createBuffer
+    this.buffer = device.createBuffer({
+      viewOrSize: typed,
+      usage: isUBO ? BufferUsage.UNIFORM : BufferUsage.VERTEX,
+      hint: hintMap[usage || gl.STATIC_DRAW]
+    });
+  }
+  _createClass(DeviceBuffer, [{
+    key: "get",
+    value: function get() {
+      return this.buffer;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (!this.isDestroyed) {
+        this.buffer.destroy();
+      }
+      this.isDestroyed = true;
+    }
+  }, {
+    key: "subData",
+    value: function subData(_ref) {
+      var data = _ref.data,
+        offset = _ref.offset;
+      var typed;
+      if (isTypedArray(data)) {
+        typed = data;
+      } else {
+        typed = new typedArrayCtorMap[this.type || gl.FLOAT](data);
+      }
+      this.buffer.setSubData(offset, new Uint8Array(typed.buffer));
+    }
+  }]);
+  return DeviceBuffer;
+}();
+export { DeviceBuffer as default };

package/es/device/DeviceElements.d.ts

@@ -0,0 +1,13 @@
+import { Buffer, Device } from '@antv/g-device-api';
+import { 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,52 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import { BufferUsage } from '@antv/g-device-api';
+import { gl } from '@antv/l7-core';
+import { typedArrayCtorMap } from "./constants";
+import { isTypedArray } from "./utils/typedarray";
+var DeviceElements = /*#__PURE__*/function () {
+  function DeviceElements(device, options) {
+    _classCallCheck(this, DeviceElements);
+    var data = options.data,
+      type = options.type,
+      _options$count = options.count,
+      count = _options$count === void 0 ? 0 : _options$count;
+    var 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
+    });
+  }
+  _createClass(DeviceElements, [{
+    key: "get",
+    value: function get() {
+      return this.indexBuffer;
+    }
+  }, {
+    key: "subData",
+    value: function subData(_ref) {
+      var data = _ref.data;
+      var typed;
+      if (isTypedArray(data)) {
+        typed = data;
+      } else {
+        typed = new typedArrayCtorMap[this.type || gl.UNSIGNED_INT](data);
+      }
+      this.indexBuffer.setSubData(0, new Uint8Array(typed.buffer));
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.indexBuffer.destroy();
+    }
+  }]);
+  return DeviceElements;
+}();
+export { DeviceElements as default };

package/es/device/DeviceFramebuffer.d.ts

@@ -0,0 +1,15 @@
+import { Device, RenderTarget } from '@antv/g-device-api';
+import { IFramebuffer, IFramebufferInitializationOptions } from '@antv/l7-core';
+export default class DeviceFramebuffer implements IFramebuffer {
+    private device;
+    private renderTarget;
+    private width;
+    private height;
+    constructor(device: Device, options: IFramebufferInitializationOptions);
+    get(): RenderTarget;
+    destroy(): void;
+    resize({ width, height }: {
+        width: number;
+        height: number;
+    }): void;
+}

package/es/device/DeviceFramebuffer.js

@@ -0,0 +1,58 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import { Format } from '@antv/g-device-api';
+import { isTexture2D } from "./DeviceTexture2D";
+var DeviceFramebuffer = /*#__PURE__*/function () {
+  function DeviceFramebuffer(device, options) {
+    _classCallCheck(this, DeviceFramebuffer);
+    this.device = device;
+    // TODO: depth
+    var width = options.width,
+      height = options.height,
+      color = options.color;
+    if (isTexture2D(color)) {
+      this.renderTarget = device.createRenderTargetFromTexture(color.get());
+      this.width = color['width'];
+      this.height = color['height'];
+    } else if (width && height) {
+      this.renderTarget = device.createRenderTarget({
+        format: Format.U8_RGBA_RT,
+        width: width,
+        height: height
+      });
+      this.width = width;
+      this.height = height;
+    }
+  }
+  _createClass(DeviceFramebuffer, [{
+    key: "get",
+    value: function get() {
+      return this.renderTarget;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.renderTarget.destroy();
+    }
+  }, {
+    key: "resize",
+    value: function resize(_ref) {
+      var width = _ref.width,
+        height = _ref.height;
+      if (this.width !== width || this.height !== height) {
+        if (this.renderTarget) {
+          this.renderTarget.destroy();
+        }
+        this.renderTarget = this.device.createRenderTarget({
+          format: Format.U8_RGBA_RT,
+          width: width,
+          height: height
+        });
+        this.width = width;
+        this.height = height;
+      }
+    }
+  }]);
+  return DeviceFramebuffer;
+}();
+export { DeviceFramebuffer as default };

package/es/device/DeviceModel.d.ts

@@ -0,0 +1,36 @@
+import { Device } from '@antv/g-device-api';
+import { IModel, IModelDrawOptions, IModelInitializationOptions, IUniform } from '@antv/l7-core';
+export default class DeviceModel implements IModel {
+    private device;
+    private options;
+    private destroyed;
+    private uniforms;
+    private program;
+    private inputLayout;
+    private pipeline;
+    private indexBuffer;
+    private vertexBuffers;
+    private bindings;
+    constructor(device: Device, options: IModelInitializationOptions);
+    private createPipeline;
+    updateAttributesAndElements(): void;
+    updateAttributes(): void;
+    addUniforms(uniforms: {
+        [key: string]: IUniform;
+    }): void;
+    draw(options: IModelDrawOptions): void;
+    destroy(): void;
+    private initDepthDrawParams;
+    private getBlendDrawParams;
+    /**
+     * @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;
+}