@antv/l7-renderer 2.19.11 → 2.20.0

package/es/device/DeviceModel.js

@@ -0,0 +1,414 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+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 { BlendFactor, BlendMode, ChannelWriteMask, CompareFunction, CullMode, Format, TransparentBlack, VertexStepMode } from '@antv/g-device-api';
+import { gl } from '@antv/l7-core';
+import { lodashUtil } from '@antv/l7-utils';
+import { blendEquationMap, blendFuncMap, cullFaceMap, depthFuncMap, primitiveMap, sizeFormatMap } from "./constants";
+var isPlainObject = lodashUtil.isPlainObject,
+  isTypedArray = lodashUtil.isTypedArray;
+var DeviceModel = /*#__PURE__*/function () {
+  function DeviceModel(device, options) {
+    var _this = this;
+    _classCallCheck(this, DeviceModel);
+    _defineProperty(this, "destroyed", false);
+    _defineProperty(this, "uniforms", {});
+    _defineProperty(this, "vertexBuffers", []);
+    this.device = device;
+    this.options = options;
+    var vs = options.vs,
+      fs = options.fs,
+      attributes = options.attributes,
+      uniforms = options.uniforms,
+      count = options.count,
+      elements = options.elements;
+    this.options = options;
+    var program = device.createProgram({
+      vertex: {
+        glsl: vs
+      },
+      fragment: {
+        glsl: fs
+      }
+    });
+    this.program = program;
+    if (uniforms) {
+      this.uniforms = this.extractUniforms(uniforms);
+    }
+    var vertexBufferDescriptors = [];
+
+    // Infer count from data if not provided.
+    var inferredCount = 0;
+    Object.keys(attributes).forEach(function (name) {
+      var attribute = attributes[name];
+      var buffer = attribute.get();
+      // Bind at each frame.
+      _this.vertexBuffers.push(buffer.get());
+      var _attribute$attribute = attribute['attribute'],
+        _attribute$attribute$ = _attribute$attribute.offset,
+        offset = _attribute$attribute$ === void 0 ? 0 : _attribute$attribute$,
+        _attribute$attribute$2 = _attribute$attribute.stride,
+        stride = _attribute$attribute$2 === void 0 ? 0 : _attribute$attribute$2,
+        _attribute$attribute$3 = _attribute$attribute.size,
+        size = _attribute$attribute$3 === void 0 ? 1 : _attribute$attribute$3,
+        _attribute$attribute$4 = _attribute$attribute.divisor,
+        divisor = _attribute$attribute$4 === void 0 ? 0 : _attribute$attribute$4,
+        _attribute$attribute$5 = _attribute$attribute.shaderLocation,
+        shaderLocation = _attribute$attribute$5 === void 0 ? 0 : _attribute$attribute$5;
+      vertexBufferDescriptors.push({
+        arrayStride: stride || size * 4,
+        // TODO: L7 hasn't use instanced array for now.
+        stepMode: VertexStepMode.VERTEX,
+        attributes: [{
+          format: sizeFormatMap[size],
+          shaderLocation: shaderLocation,
+          offset: offset,
+          divisor: divisor
+        }]
+      });
+      inferredCount = buffer['size'] / size;
+    });
+    if (!count) {
+      this.options.count = inferredCount;
+    }
+    if (elements) {
+      this.indexBuffer = elements.get();
+    }
+    var inputLayout = device.createInputLayout({
+      vertexBufferDescriptors: vertexBufferDescriptors,
+      indexBufferFormat: elements ? Format.U32_R : null,
+      program: program
+    });
+    this.inputLayout = inputLayout;
+    this.pipeline = this.createPipeline(options);
+  }
+  _createClass(DeviceModel, [{
+    key: "createPipeline",
+    value: function createPipeline(options) {
+      var _options$primitive = options.primitive,
+        primitive = _options$primitive === void 0 ? gl.TRIANGLES : _options$primitive,
+        depth = options.depth,
+        cull = options.cull,
+        blend = options.blend;
+      var depthParams = this.initDepthDrawParams({
+        depth: depth
+      });
+      var depthEnabled = !!(depthParams && depthParams.enable);
+      var cullParams = this.initCullDrawParams({
+        cull: cull
+      });
+      var cullEnabled = !!(cullParams && cullParams.enable);
+      var blendParams = this.getBlendDrawParams({
+        blend: blend
+      });
+      var blendEnabled = !!(blendParams && blendParams.enable);
+      return this.device.createRenderPipeline({
+        inputLayout: this.inputLayout,
+        program: this.program,
+        topology: primitiveMap[primitive],
+        colorAttachmentFormats: [Format.U8_RGBA_RT],
+        depthStencilAttachmentFormat: Format.D24_S8,
+        megaStateDescriptor: {
+          attachmentsState: [{
+            channelWriteMask: ChannelWriteMask.ALL,
+            rgbBlendState: {
+              blendMode: blendEnabled && blendParams.equation.rgb || BlendMode.ADD,
+              blendSrcFactor: blendEnabled && blendParams.func.srcRGB || BlendFactor.SRC_ALPHA,
+              blendDstFactor: blendEnabled && blendParams.func.dstRGB || BlendFactor.ONE_MINUS_SRC_ALPHA
+            },
+            alphaBlendState: {
+              blendMode: blendEnabled && blendParams.equation.alpha || BlendMode.ADD,
+              blendSrcFactor: blendEnabled && blendParams.func.srcAlpha || BlendFactor.ONE,
+              blendDstFactor: blendEnabled && blendParams.func.dstAlpha || BlendFactor.ONE_MINUS_SRC_ALPHA
+            }
+          }],
+          blendConstant: TransparentBlack,
+          depthWrite: depthEnabled,
+          depthCompare: depthEnabled && depthParams.func || CompareFunction.LESS,
+          cullMode: cullEnabled && cullParams.face || CullMode.NONE,
+          stencilWrite: false
+        }
+      });
+    }
+  }, {
+    key: "updateAttributesAndElements",
+    value: function updateAttributesAndElements()
+    // elements: IElements, // attributes: { [key: string]: IAttribute },
+    {
+      // TODO: implement
+    }
+  }, {
+    key: "updateAttributes",
+    value: function updateAttributes() {// attributes: { [key: string]: IAttribute }
+      // TODO: implement
+      // Object.keys(attributes).forEach((name: string) => {
+      //   const attribute = attributes[name] as DeviceAttribute;
+      //   attribute.updateBuffer();
+      // });
+    }
+  }, {
+    key: "addUniforms",
+    value: function addUniforms(uniforms) {
+      this.uniforms = _objectSpread(_objectSpread({}, this.uniforms), this.extractUniforms(uniforms));
+    }
+  }, {
+    key: "draw",
+    value: function draw(options
+    //  pick?: boolean
+    ) {
+      var mergedOptions = _objectSpread(_objectSpread({}, this.options), options);
+      var _mergedOptions$count = mergedOptions.count,
+        count = _mergedOptions$count === void 0 ? 0 : _mergedOptions$count,
+        instances = mergedOptions.instances,
+        elements = mergedOptions.elements,
+        _mergedOptions$unifor = mergedOptions.uniforms,
+        uniforms = _mergedOptions$unifor === void 0 ? {} : _mergedOptions$unifor,
+        uniformBuffers = mergedOptions.uniformBuffers,
+        textures = mergedOptions.textures;
+      this.uniforms = _objectSpread(_objectSpread({}, this.uniforms), this.extractUniforms(uniforms));
+
+      // @ts-ignore
+      var _this$device = this.device,
+        width = _this$device.width,
+        height = _this$device.height;
+
+      // @ts-ignore
+      // const renderTarget = this.device.currentFramebuffer;
+      // const { onscreen } = renderTarget
+
+      // @ts-ignore
+      var renderPass = this.device.renderPass;
+      // TODO: Recreate pipeline only when blend / cull changed.
+      this.pipeline = this.createPipeline(mergedOptions);
+      renderPass.setPipeline(this.pipeline);
+      renderPass.setVertexInput(this.inputLayout, this.vertexBuffers.map(function (buffer) {
+        return {
+          buffer: buffer
+        };
+      }), elements ? {
+        buffer: this.indexBuffer,
+        offset: 0 // TODO: use defaule value
+      } : null);
+      renderPass.setViewport(0, 0, width, height);
+      if (uniformBuffers) {
+        this.bindings = this.device.createBindings({
+          pipeline: this.pipeline,
+          uniformBufferBindings: uniformBuffers.map(function (uniformBuffer, i) {
+            var buffer = uniformBuffer;
+            return {
+              binding: i,
+              buffer: buffer.get(),
+              size: buffer['size']
+            };
+          }),
+          samplerBindings: textures === null || textures === void 0 ? void 0 : textures.map(function (t) {
+            return {
+              texture: t['texture'],
+              sampler: t['sampler']
+            };
+          })
+        });
+      }
+      if (this.bindings) {
+        renderPass.setBindings(this.bindings);
+        // Compatible to WebGL1.
+        this.program.setUniformsLegacy(this.uniforms);
+      }
+      if (elements) {
+        var indexCount = elements['count'];
+        if (indexCount === 0) {
+          renderPass.draw(count, instances);
+        } else {
+          renderPass.drawIndexed(indexCount, instances);
+        }
+      } else {
+        renderPass.draw(count, instances);
+      }
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      var _this$vertexBuffers, _this$indexBuffer, _this$bindings;
+      this.program.destroy();
+      (_this$vertexBuffers = this.vertexBuffers) === null || _this$vertexBuffers === void 0 || _this$vertexBuffers.forEach(function (buffer) {
+        return buffer.destroy();
+      });
+      (_this$indexBuffer = this.indexBuffer) === null || _this$indexBuffer === void 0 || _this$indexBuffer.destroy();
+      (_this$bindings = this.bindings) === null || _this$bindings === void 0 || _this$bindings.destroy();
+      this.inputLayout.destroy();
+      this.pipeline.destroy();
+      this.destroyed = true;
+    }
+  }, {
+    key: "initDepthDrawParams",
+    value: function initDepthDrawParams(_ref) {
+      var depth = _ref.depth;
+      if (depth) {
+        return {
+          enable: depth.enable === undefined ? true : !!depth.enable,
+          mask: depth.mask === undefined ? true : !!depth.mask,
+          func: depthFuncMap[depth.func || gl.LESS],
+          range: depth.range || [0, 1]
+        };
+      }
+    }
+  }, {
+    key: "getBlendDrawParams",
+    value: function getBlendDrawParams(_ref2) {
+      var blend = _ref2.blend;
+      var _ref3 = blend || {},
+        enable = _ref3.enable,
+        func = _ref3.func,
+        equation = _ref3.equation,
+        _ref3$color = _ref3.color,
+        color = _ref3$color === void 0 ? [0, 0, 0, 0] : _ref3$color;
+      return {
+        enable: !!enable,
+        func: {
+          srcRGB: blendFuncMap[func && func.srcRGB || gl.SRC_ALPHA],
+          srcAlpha: blendFuncMap[func && func.srcAlpha || gl.SRC_ALPHA],
+          dstRGB: blendFuncMap[func && func.dstRGB || gl.ONE_MINUS_SRC_ALPHA],
+          dstAlpha: blendFuncMap[func && func.dstAlpha || gl.ONE_MINUS_SRC_ALPHA]
+        },
+        equation: {
+          rgb: blendEquationMap[equation && equation.rgb || gl.FUNC_ADD],
+          alpha: blendEquationMap[equation && equation.alpha || gl.FUNC_ADD]
+        },
+        color: color
+      };
+    }
+
+    // /**
+    //  * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#stencil
+    //  */
+    // private getStencilDrawParams({
+    //   stencil,
+    // }: Pick<IModelInitializationOptions, 'stencil'>) {
+    //   const {
+    //     enable,
+    //     mask = -1,
+    //     func = {
+    //       cmp: gl.ALWAYS,
+    //       ref: 0,
+    //       mask: -1,
+    //     },
+    //     opFront = {
+    //       fail: gl.KEEP,
+    //       zfail: gl.KEEP,
+    //       zpass: gl.KEEP,
+    //     },
+    //     opBack = {
+    //       fail: gl.KEEP,
+    //       zfail: gl.KEEP,
+    //       zpass: gl.KEEP,
+    //     },
+    //   } = stencil || {};
+    //   return {
+    //     enable: !!enable,
+    //     mask,
+    //     func: {
+    //       ...func,
+    //       cmp: stencilFuncMap[func.cmp],
+    //     },
+    //     opFront: {
+    //       fail: stencilOpMap[opFront.fail],
+    //       zfail: stencilOpMap[opFront.zfail],
+    //       zpass: stencilOpMap[opFront.zpass],
+    //     },
+    //     opBack: {
+    //       fail: stencilOpMap[opBack.fail],
+    //       zfail: stencilOpMap[opBack.zfail],
+    //       zpass: stencilOpMap[opBack.zpass],
+    //     },
+    //   };
+    // }
+
+    // private getColorMaskDrawParams(
+    //   { stencil }: Pick<IModelInitializationOptions, 'stencil'>,
+    //   pick: boolean,
+    // ) {
+    //   // TODO: 重构相关参数
+    //   // 掩膜模式下，颜色通道全部关闭
+    //   const colorMask =
+    //     stencil?.enable && stencil.opFront && !pick
+    //       ? [false, false, false, false]
+    //       : [true, true, true, true]; // 非掩码模式下，颜色通道全部开启
+    //   return colorMask;
+    // }
+
+    /**
+     * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#culling
+     */
+  }, {
+    key: "initCullDrawParams",
+    value: function initCullDrawParams(_ref4) {
+      var cull = _ref4.cull;
+      if (cull) {
+        var enable = cull.enable,
+          _cull$face = cull.face,
+          face = _cull$face === void 0 ? gl.BACK : _cull$face;
+        return {
+          enable: !!enable,
+          face: cullFaceMap[face]
+        };
+      }
+    }
+
+    /**
+     * 考虑结构体命名, eg:
+     * a: { b: 1 }  ->  'a.b'
+     * a: [ { b: 1 } ] -> 'a[0].b'
+     */
+  }, {
+    key: "extractUniforms",
+    value: function extractUniforms(uniforms) {
+      var _this2 = this;
+      var extractedUniforms = {};
+      Object.keys(uniforms).forEach(function (uniformName) {
+        _this2.extractUniformsRecursively(uniformName, uniforms[uniformName], extractedUniforms, '');
+      });
+      return extractedUniforms;
+    }
+  }, {
+    key: "extractUniformsRecursively",
+    value: function extractUniformsRecursively(uniformName, uniformValue, uniforms, prefix) {
+      var _this3 = this;
+      if (uniformValue === null || typeof uniformValue === 'number' ||
+      // u_A: 1
+      typeof uniformValue === 'boolean' ||
+      // u_A: false
+      Array.isArray(uniformValue) && typeof uniformValue[0] === 'number' ||
+      // u_A: [1, 2, 3]
+      isTypedArray(uniformValue) ||
+      // u_A: Float32Array
+      // @ts-ignore
+      uniformValue === '' || 'resize' in uniformValue) {
+        uniforms["".concat(prefix && prefix + '.').concat(uniformName)] = uniformValue;
+        return;
+      }
+
+      // u_Struct.a.b.c
+      if (isPlainObject(uniformValue)) {
+        Object.keys(uniformValue).forEach(function (childName) {
+          _this3.extractUniformsRecursively(childName,
+          // @ts-ignore
+          uniformValue[childName], uniforms, "".concat(prefix && prefix + '.').concat(uniformName));
+        });
+      }
+
+      // u_Struct[0].a
+      if (Array.isArray(uniformValue)) {
+        uniformValue.forEach(function (child, idx) {
+          Object.keys(child).forEach(function (childName) {
+            _this3.extractUniformsRecursively(childName,
+            // @ts-ignore
+            child[childName], uniforms, "".concat(prefix && prefix + '.').concat(uniformName, "[").concat(idx, "]"));
+          });
+        });
+      }
+    }
+  }]);
+  return DeviceModel;
+}();
+export { DeviceModel as default };

package/es/device/DeviceTexture2D.d.ts

@@ -0,0 +1,20 @@
+import { Device, Texture } from '@antv/g-device-api';
+import { ITexture2D, ITexture2DInitializationOptions } from '@antv/l7-core';
+export declare function isTexture2D(t: any): t is ITexture2D;
+export default class DeviceTexture2D implements ITexture2D {
+    private texture;
+    private sampler;
+    private width;
+    private height;
+    private isDestroy;
+    constructor(device: Device, options: ITexture2DInitializationOptions);
+    get(): Texture;
+    update(props: any): void;
+    bind(): void;
+    resize({ width, height }: {
+        width: number;
+        height: number;
+    }): void;
+    getSize(): [number, number];
+    destroy(): void;
+}

package/es/device/DeviceTexture2D.js

@@ -0,0 +1,116 @@
+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 { FilterMode, Format, MipmapFilterMode, TextureUsage } from '@antv/g-device-api';
+import { gl } from '@antv/l7-core';
+import { wrapModeMap } from "./constants";
+export function isTexture2D(t) {
+  return false;
+}
+var DeviceTexture2D = /*#__PURE__*/function () {
+  function DeviceTexture2D(device, options) {
+    _classCallCheck(this, DeviceTexture2D);
+    _defineProperty(this, "isDestroy", false);
+    var data = options.data,
+      _options$type = options.type,
+      type = _options$type === void 0 ? gl.UNSIGNED_BYTE : _options$type,
+      width = options.width,
+      height = options.height,
+      _options$flipY = options.flipY,
+      flipY = _options$flipY === void 0 ? false : _options$flipY,
+      _options$format = options.format,
+      format = _options$format === void 0 ? gl.RGBA : _options$format,
+      _options$wrapS = options.wrapS,
+      wrapS = _options$wrapS === void 0 ? gl.CLAMP_TO_EDGE : _options$wrapS,
+      _options$wrapT = options.wrapT,
+      wrapT = _options$wrapT === void 0 ? gl.CLAMP_TO_EDGE : _options$wrapT,
+      _options$alignment = options.alignment,
+      alignment = _options$alignment === void 0 ? 1 : _options$alignment;
+    this.width = width;
+    this.height = height;
+    var pixelFormat = Format.U8_RGBA_RT;
+    if (type === gl.UNSIGNED_BYTE && format === gl.RGBA) {
+      pixelFormat = Format.U8_RGBA_RT;
+    } else if (format === gl.LUMINANCE && type === gl.FLOAT) {
+      pixelFormat = Format.F32_LUMINANCE;
+    } else if (format === gl.LUMINANCE && type === gl.UNSIGNED_BYTE) {
+      pixelFormat = Format.U8_LUMINANCE;
+    } else {
+      throw new Error("create texture error, type: ".concat(type, ", format: ").concat(format));
+    }
+
+    //   // copy pixels from current bind framebuffer
+    //   x,
+    //   y,
+    //   copy,
+    // };
+
+    this.texture = device.createTexture({
+      format: pixelFormat,
+      width: width,
+      height: height,
+      usage: TextureUsage.SAMPLED,
+      pixelStore: {
+        unpackFlipY: flipY,
+        packAlignment: alignment
+      }
+    });
+    if (data) {
+      // @ts-ignore
+      this.texture.setImageData([data]);
+    }
+    this.sampler = device.createSampler({
+      addressModeU: wrapModeMap[wrapS],
+      addressModeV: wrapModeMap[wrapT],
+      minFilter: FilterMode.POINT,
+      // TODO: use mag & min
+      magFilter: FilterMode.BILINEAR,
+      mipmapFilter: MipmapFilterMode.NO_MIP,
+      lodMinClamp: 0,
+      lodMaxClamp: 0
+      // maxAnisotropy: aniso,
+    });
+  }
+  _createClass(DeviceTexture2D, [{
+    key: "get",
+    value: function get() {
+      return this.texture;
+    }
+  }, {
+    key: "update",
+    value: function update(props) {
+      var data = props.data;
+      this.texture.setImageData([data]);
+    }
+  }, {
+    key: "bind",
+    value: function bind() {
+      // this.texture._texture.bind();
+    }
+  }, {
+    key: "resize",
+    value: function resize(_ref) {
+      var width = _ref.width,
+        height = _ref.height;
+      // this.texture.resize(width, height);
+      this.width = width;
+      this.height = height;
+    }
+  }, {
+    key: "getSize",
+    value: function getSize() {
+      return [this.width, this.height];
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (!this.isDestroy) {
+        var _this$texture;
+        (_this$texture = this.texture) === null || _this$texture === void 0 || _this$texture.destroy();
+      }
+      this.isDestroy = true;
+    }
+  }]);
+  return DeviceTexture2D;
+}();
+export { DeviceTexture2D as default };

package/es/device/constants.d.ts

@@ -0,0 +1,29 @@
+import { AddressMode, BlendFactor, BlendMode, BufferFrequencyHint, CompareFunction, CullMode, Format, PrimitiveTopology } from '@antv/g-device-api';
+import { 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;
+};

package/es/device/constants.js

@@ -0,0 +1,32 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+var _typedArrayCtorMap, _primitiveMap, _sizeFormatMap, _hintMap, _wrapModeMap, _depthFuncMap, _cullFaceMap, _blendEquationMap, _blendFuncMap;
+import { AddressMode, BlendFactor, BlendMode, BufferFrequencyHint, CompareFunction, CullMode, Format, PrimitiveTopology } from '@antv/g-device-api';
+import { gl } from '@antv/l7-core';
+export var typedArrayCtorMap = (_typedArrayCtorMap = {}, _defineProperty(_typedArrayCtorMap, gl.FLOAT, Float32Array), _defineProperty(_typedArrayCtorMap, gl.UNSIGNED_BYTE, Uint8Array), _defineProperty(_typedArrayCtorMap, gl.SHORT, Int16Array), _defineProperty(_typedArrayCtorMap, gl.UNSIGNED_SHORT, Uint16Array), _defineProperty(_typedArrayCtorMap, gl.INT, Int32Array), _defineProperty(_typedArrayCtorMap, gl.UNSIGNED_INT, Uint32Array), _typedArrayCtorMap);
+export var primitiveMap = (_primitiveMap = {}, _defineProperty(_primitiveMap, gl.POINTS, PrimitiveTopology.POINTS), _defineProperty(_primitiveMap, gl.LINES, PrimitiveTopology.LINES), _defineProperty(_primitiveMap, gl.LINE_LOOP, PrimitiveTopology.LINES), _defineProperty(_primitiveMap, gl.LINE_STRIP, PrimitiveTopology.LINE_STRIP), _defineProperty(_primitiveMap, gl.TRIANGLES, PrimitiveTopology.TRIANGLES), _defineProperty(_primitiveMap, gl.TRIANGLE_FAN, PrimitiveTopology.TRIANGLES), _defineProperty(_primitiveMap, gl.TRIANGLE_STRIP, PrimitiveTopology.TRIANGLE_STRIP), _primitiveMap);
+export var sizeFormatMap = (_sizeFormatMap = {}, _defineProperty(_sizeFormatMap, 1, Format.F32_R), _defineProperty(_sizeFormatMap, 2, Format.F32_RG), _defineProperty(_sizeFormatMap, 3, Format.F32_RGB), _defineProperty(_sizeFormatMap, 4, Format.F32_RGBA), _sizeFormatMap);
+export var hintMap = (_hintMap = {}, _defineProperty(_hintMap, gl.STATIC_DRAW, BufferFrequencyHint.STATIC), _defineProperty(_hintMap, gl.DYNAMIC_DRAW, BufferFrequencyHint.DYNAMIC), _defineProperty(_hintMap, gl.STREAM_DRAW, BufferFrequencyHint.DYNAMIC), _hintMap);
+export var wrapModeMap = (_wrapModeMap = {}, _defineProperty(_wrapModeMap, gl.REPEAT, AddressMode.REPEAT), _defineProperty(_wrapModeMap, gl.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE), _defineProperty(_wrapModeMap, gl.MIRRORED_REPEAT, AddressMode.MIRRORED_REPEAT), _wrapModeMap);
+export var depthFuncMap = (_depthFuncMap = {}, _defineProperty(_depthFuncMap, gl.NEVER, CompareFunction.NEVER), _defineProperty(_depthFuncMap, gl.ALWAYS, CompareFunction.ALWAYS), _defineProperty(_depthFuncMap, gl.LESS, CompareFunction.LESS), _defineProperty(_depthFuncMap, gl.LEQUAL, CompareFunction.LEQUAL), _defineProperty(_depthFuncMap, gl.GREATER, CompareFunction.GREATER), _defineProperty(_depthFuncMap, gl.GEQUAL, CompareFunction.GEQUAL), _defineProperty(_depthFuncMap, gl.EQUAL, CompareFunction.EQUAL), _defineProperty(_depthFuncMap, gl.NOTEQUAL, CompareFunction.NOTEQUAL), _depthFuncMap);
+export var cullFaceMap = (_cullFaceMap = {}, _defineProperty(_cullFaceMap, gl.FRONT, CullMode.FRONT), _defineProperty(_cullFaceMap, gl.BACK, CullMode.BACK), _cullFaceMap);
+export var blendEquationMap = (_blendEquationMap = {}, _defineProperty(_blendEquationMap, gl.FUNC_ADD, BlendMode.ADD), _defineProperty(_blendEquationMap, gl.MIN_EXT, BlendMode.MIN), _defineProperty(_blendEquationMap, gl.MAX_EXT, BlendMode.MAX), _defineProperty(_blendEquationMap, gl.FUNC_SUBTRACT, BlendMode.SUBSTRACT), _defineProperty(_blendEquationMap, gl.FUNC_REVERSE_SUBTRACT, BlendMode.REVERSE_SUBSTRACT), _blendEquationMap);
+export var blendFuncMap = (_blendFuncMap = {}, _defineProperty(_blendFuncMap, gl.ZERO, BlendFactor.ZERO), _defineProperty(_blendFuncMap, gl.ONE, BlendFactor.ONE), _defineProperty(_blendFuncMap, gl.SRC_COLOR, BlendFactor.SRC), _defineProperty(_blendFuncMap, gl.ONE_MINUS_SRC_COLOR, BlendFactor.ONE_MINUS_SRC), _defineProperty(_blendFuncMap, gl.SRC_ALPHA, BlendFactor.SRC_ALPHA), _defineProperty(_blendFuncMap, gl.ONE_MINUS_SRC_ALPHA, BlendFactor.ONE_MINUS_SRC_ALPHA), _defineProperty(_blendFuncMap, gl.DST_COLOR, BlendFactor.DST), _defineProperty(_blendFuncMap, gl.ONE_MINUS_DST_COLOR, BlendFactor.ONE_MINUS_DST), _defineProperty(_blendFuncMap, gl.DST_ALPHA, BlendFactor.DST_ALPHA), _defineProperty(_blendFuncMap, gl.ONE_MINUS_DST_ALPHA, BlendFactor.ONE_MINUS_DST_ALPHA), _defineProperty(_blendFuncMap, gl.CONSTANT_COLOR, BlendFactor.CONST), _defineProperty(_blendFuncMap, gl.ONE_MINUS_CONSTANT_COLOR, BlendFactor.ONE_MINUS_CONSTANT), _defineProperty(_blendFuncMap, gl.CONSTANT_ALPHA, BlendFactor.CONST), _defineProperty(_blendFuncMap, gl.ONE_MINUS_CONSTANT_ALPHA, BlendFactor.ONE_MINUS_CONSTANT), _defineProperty(_blendFuncMap, gl.SRC_ALPHA_SATURATE, BlendFactor.SRC_ALPHA_SATURATE), _blendFuncMap);
+
+// export const filterMap: {
+//   [key: string]: FilterMode;
+// } = {
+//   [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',
+// };
+
+// export const mipmapMap: {
+//   [key: string]: MipmapFilterMode;
+// } = {
+//   [gl.DONT_CARE]: MipmapFilterMode,
+//   [gl.NICEST]: 'nice',
+//   [gl.FASTEST]: 'fast',
+// };

package/es/device/index.d.ts

@@ -0,0 +1,53 @@
+import { IAttribute, IAttributeInitializationOptions, IBuffer, IBufferInitializationOptions, IElements, IElementsInitializationOptions, IExtensions, IFramebufferInitializationOptions, IModel, IModelInitializationOptions, IRenderConfig, IRendererService, ITexture2D, ITexture2DInitializationOptions } from '@antv/l7-core';
+import 'reflect-metadata';
+import DeviceFramebuffer from './DeviceFramebuffer';
+/**
+ * Device API renderer
+ */
+export default class DeviceRendererService implements IRendererService {
+    uniformBuffers: IBuffer[];
+    extensionObject: IExtensions;
+    private device;
+    private swapChain;
+    private $container;
+    private canvas;
+    private width;
+    private height;
+    private isDirty;
+    private renderPass;
+    private renderTarget;
+    private mainDepthRT;
+    init(canvas: HTMLCanvasElement, cfg: IRenderConfig): Promise<void>;
+    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: () => void;
+    clear: () => void;
+    viewport: ({ width, height, }: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }) => void;
+    readPixels: () => Uint8Array;
+    getViewportSize: () => {
+        width: any;
+        height: any;
+    };
+    getContainer: () => HTMLElement | null;
+    getCanvas: () => HTMLCanvasElement;
+    getGLContext: () => WebGLRenderingContext;
+    setState(): void;
+    setBaseState(): void;
+    setCustomLayerDefaults(): void;
+    setDirty(flag: boolean): void;
+    getDirty(): boolean;
+    destroy: () => void;
+}