@antv/l7-renderer 2.21.1 → 2.21.2

package/lib/device/DeviceModel.js

@@ -1,9 +1,26 @@
 var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -196,16 +213,10 @@ var DeviceModel = class {
   updateAttributes() {
   }
   addUniforms(uniforms) {
-    this.uniforms = {
-      ...this.uniforms,
-      ...this.extractUniforms(uniforms)
-    };
+    this.uniforms = __spreadValues(__spreadValues({}, this.uniforms), this.extractUniforms(uniforms));
   }
   draw(options, pick) {
-    const mergedOptions = {
-      ...this.options,
-      ...options
-    };
+    const mergedOptions = __spreadValues(__spreadValues({}, this.options), options);
     const {
       count = 0,
       instances,
@@ -214,10 +225,7 @@ var DeviceModel = class {
       uniformBuffers,
       textures
     } = mergedOptions;
-    this.uniforms = {
-      ...this.uniforms,
-      ...this.extractUniforms(uniforms)
-    };
+    this.uniforms = __spreadValues(__spreadValues({}, this.uniforms), this.extractUniforms(uniforms));
     const { renderPass, currentFramebuffer, width, height, renderCache } = this.service;
     this.pipeline = this.createPipeline(mergedOptions, pick);
     const device = this.service["device"];
@@ -351,10 +359,9 @@ var DeviceModel = class {
     return {
       enable: !!enable,
       mask,
-      func: {
-        ...func,
+      func: __spreadProps(__spreadValues({}, func), {
         cmp: import_constants.stencilFuncMap[func.cmp]
-      },
+      }),
       opFront: {
         fail: import_constants.stencilOpMap[opFront.fail],
         zfail: import_constants.stencilOpMap[opFront.zfail],

package/lib/device/DeviceTexture2D.d.ts

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

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/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

@@ -25,6 +25,26 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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 = {};
@@ -62,15 +82,15 @@ var DeviceRendererService = class {
       this.endFrame();
       this.currentFramebuffer = null;
     };
-    this.useFramebufferAsync = async (framebuffer, drawCommands) => {
+    this.useFramebufferAsync = (framebuffer, drawCommands) => __async(this, null, function* () {
       this.currentFramebuffer = framebuffer;
       this.preRenderPass = this.renderPass;
       this.beginFrame();
-      await drawCommands();
+      yield drawCommands();
       this.endFrame();
       this.currentFramebuffer = null;
       this.renderPass = this.preRenderPass;
-    };
+    });
     this.clear = (options) => {
       const { color, depth, stencil, framebuffer = null } = options;
       if (framebuffer) {
@@ -126,11 +146,11 @@ var DeviceRendererService = class {
       readback.destroy();
       return result;
     };
-    this.readPixelsAsync = async (options) => {
+    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 = await readback.readTexture(
+      const result = yield readback.readTexture(
         texture,
         x,
         /**
@@ -151,7 +171,7 @@ var DeviceRendererService = class {
       }
       readback.destroy();
       return result;
-    };
+    });
     this.getViewportSize = () => {
       return {
         width: this.width,
@@ -178,37 +198,39 @@ var DeviceRendererService = class {
       this.renderCache.destroy();
     };
   }
-  async init(canvas, cfg) {
-    const { enableWebGPU, shaderCompilerPath } = 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"],
-      onContextLost(e) {
-        console.warn("context lost", e);
-      },
-      onContextCreationError(e) {
-        console.warn("context creation error", e);
-      },
-      onContextRestored(e) {
-        console.warn("context restored", e);
-      }
+  init(canvas, cfg) {
+    return __async(this, null, function* () {
+      const { enableWebGPU, shaderCompilerPath } = 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"],
+        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);
     });
-    const swapChain = await 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) {

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 {};

package/lib/device/utils/pipeline.d.ts

@@ -0,0 +1 @@
+export declare function pipelineEquals(): void;

package/lib/device/utils/typedarray.d.ts

@@ -0,0 +1,7 @@
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
+export declare function isTypedArray(x: any): x is TypedArray;
+/**
+ * WebGPU does not support RGB texture, so we need to convert RGB to RGBA
+ * @see https://github.com/antvis/L7/pull/2262
+ */
+export declare function extend3ChannelsTo4(array: Float32Array, valueToInsert: number): Float32Array;

package/lib/device/utils/webgl.d.ts

@@ -0,0 +1 @@
+export declare function isWebGL2(gl: WebGL2RenderingContext | WebGLRenderingContext): gl is WebGL2RenderingContext;

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ *
+ */
+import DeviceRendererService from './device';
+import ReglRendererService from './regl';
+export { DeviceRendererService, ReglRendererService };

package/lib/regl/ReglAttribute.d.ts

@@ -0,0 +1,16 @@
+import type { IAttribute, IAttributeInitializationOptions } from '@antv/l7-core';
+import type regl from 'regl';
+/**
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#attributes
+ */
+export default class ReglAttribute implements IAttribute {
+    private attribute;
+    private buffer;
+    constructor(gl: regl.Regl, options: IAttributeInitializationOptions);
+    get(): regl.Attribute;
+    updateBuffer(options: {
+        data: number[] | number[][] | Uint8Array | Uint16Array | Uint32Array;
+        offset: number;
+    }): void;
+    destroy(): void;
+}

package/lib/regl/ReglBuffer.d.ts

@@ -0,0 +1,17 @@
+import type { IBuffer, IBufferInitializationOptions } from '@antv/l7-core';
+import type regl from 'regl';
+/**
+ * adaptor for regl.Buffer
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#buffers
+ */
+export default class ReglBuffer implements IBuffer {
+    private buffer;
+    private isDestroyed;
+    constructor(reGl: regl.Regl, options: IBufferInitializationOptions);
+    get(): regl.Buffer;
+    destroy(): void;
+    subData({ data, offset, }: {
+        data: number[] | number[][] | Uint8Array | Uint16Array | Uint32Array;
+        offset: number;
+    }): void;
+}

package/lib/regl/ReglElements.d.ts

@@ -0,0 +1,14 @@
+import type { IElements, IElementsInitializationOptions } from '@antv/l7-core';
+import type regl from 'regl';
+/**
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#elements
+ */
+export default class ReglElements implements IElements {
+    private elements;
+    constructor(reGl: regl.Regl, options: IElementsInitializationOptions);
+    get(): regl.Elements;
+    subData({ data, }: {
+        data: number[] | number[][] | Uint8Array | Uint16Array | Uint32Array;
+    }): void;
+    destroy(): void;
+}

package/lib/regl/ReglFramebuffer.d.ts

@@ -0,0 +1,16 @@
+import type { IFramebuffer, IFramebufferInitializationOptions } from '@antv/l7-core';
+import type regl from 'regl';
+/**
+ * adaptor for regl.Framebuffer
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#framebuffers
+ */
+export default class ReglFramebuffer implements IFramebuffer {
+    private framebuffer;
+    constructor(reGl: regl.Regl, options: IFramebufferInitializationOptions);
+    get(): regl.Framebuffer;
+    destroy(): void;
+    resize({ width, height }: {
+        width: number;
+        height: number;
+    }): void;
+}

package/lib/regl/ReglModel.d.ts

@@ -0,0 +1,46 @@
+import type { IAttribute, IElements, IModel, IModelDrawOptions, IModelInitializationOptions, IUniform } from '@antv/l7-core';
+import type regl from 'regl';
+/**
+ * adaptor for regl.DrawCommand
+ */
+export default class ReglModel implements IModel {
+    private reGl;
+    private destroyed;
+    private drawCommand;
+    private drawParams;
+    private options;
+    private uniforms;
+    constructor(reGl: regl.Regl, options: IModelInitializationOptions);
+    updateAttributesAndElements(attributes: {
+        [key: string]: IAttribute;
+    }, elements: IElements): void;
+    updateAttributes(attributes: {
+        [key: string]: IAttribute;
+    }): void;
+    addUniforms(uniforms: {
+        [key: string]: IUniform;
+    }): void;
+    draw(options: IModelDrawOptions, pick?: boolean): void;
+    destroy(): void;
+    /**
+     * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#depth-buffer
+     */
+    private initDepthDrawParams;
+    private getBlendDrawParams;
+    /**
+     * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#stencil
+     */
+    private getStencilDrawParams;
+    private getColorMaskDrawParams;
+    /**
+     * @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;
+}

package/lib/regl/ReglModel.js

@@ -1,7 +1,24 @@
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -134,19 +151,13 @@ var ReglModel = class {
     this.drawCommand = this.reGl(this.drawParams);
   }
   addUniforms(uniforms) {
-    this.uniforms = {
-      ...this.uniforms,
-      ...this.extractUniforms(uniforms)
-    };
+    this.uniforms = __spreadValues(__spreadValues({}, this.uniforms), this.extractUniforms(uniforms));
   }
   draw(options, pick) {
     if (this.drawParams.attributes && Object.keys(this.drawParams.attributes).length === 0) {
       return;
     }
-    const uniforms = {
-      ...this.uniforms,
-      ...this.extractUniforms(options.uniforms || {})
-    };
+    const uniforms = __spreadValues(__spreadValues({}, this.uniforms), this.extractUniforms(options.uniforms || {}));
     const reglDrawProps = {};
     Object.keys(uniforms).forEach((uniformName) => {
       const type = typeof uniforms[uniformName];
@@ -234,10 +245,9 @@ var ReglModel = class {
     return {
       enable: !!enable,
       mask,
-      func: {
-        ...func,
+      func: __spreadProps(__spreadValues({}, func), {
         cmp: import_constants.stencilFuncMap[func.cmp]
-      },
+      }),
       opFront: {
         fail: import_constants.stencilOpMap[opFront.fail],
         zfail: import_constants.stencilOpMap[opFront.zfail],

package/lib/regl/ReglRenderbuffer.d.ts

@@ -0,0 +1,16 @@
+import type { IRenderbuffer, IRenderbufferInitializationOptions } from '@antv/l7-core';
+import type regl from 'regl';
+/**
+ * adaptor for regl.Renderbuffer
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#renderbuffers
+ */
+export default class ReglRenderbuffer implements IRenderbuffer {
+    private renderbuffer;
+    constructor(reGl: regl.Regl, options: IRenderbufferInitializationOptions);
+    get(): regl.Renderbuffer;
+    destroy(): void;
+    resize({ width, height }: {
+        width: number;
+        height: number;
+    }): void;
+}

package/lib/regl/ReglTexture2D.d.ts

@@ -0,0 +1,22 @@
+import type { ITexture2D, ITexture2DInitializationOptions } from '@antv/l7-core';
+import type regl from 'regl';
+/**
+ * adaptor for regl.Buffer
+ * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#buffers
+ */
+export default class ReglTexture2D implements ITexture2D {
+    private texture;
+    private width;
+    private height;
+    private isDestroy;
+    constructor(reGl: regl.Regl, options: ITexture2DInitializationOptions);
+    get(): regl.Texture2D;
+    update(props?: regl.Texture2DOptions): void;
+    bind(): void;
+    resize({ width, height }: {
+        width: number;
+        height: number;
+    }): void;
+    getSize(): [number, number];
+    destroy(): void;
+}

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