@luma.gl/webgl 9.0.11 → 9.1.0-alpha.2

package/LICENSE

@@ -0,0 +1,34 @@
+luma.gl is provided under the MIT license
+
+Copyright (c) 2020 vis.gl contributors
+
+This software includes parts initially developed by Uber and open sourced under MIT license.
+Copyright (c) 2015 Uber Technologies, Inc.
+
+This software includes parts of PhiloGL (https://github.com/philogb/philogl)
+under MIT license. PhiloGL parts Copyright © 2013 Sencha Labs.
+
+This software includes adaptations of some postprocessing code from 
+THREE.js (https://github.com/mrdoob/three.js/) under MIT license. 
+THREE.js parts Copyright © 2010-2018 three.js authors. 
+
+Additional attribution given in specific source files. 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

package/dist/adapter/converters/device-parameters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"device-parameters.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/device-parameters.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,eAAe,EAAgD,MAAM,eAAe,CAAC;AAClG,OAAO,EAAC,MAAM,EAAsB,UAAU,EAA+B,MAAM,eAAe,CAAC;AAEnG,OAAO,KAAK,EAGV,UAAU,EACV,YAAY,EAIb,MAAM,oBAAoB,CAAC;AAO5B;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,GAAG,OAAO,EACnD,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAgBH;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,OAAO,EAC1C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,YAAY,EACxB,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAeH;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,GAAG,OAAO,EAC9C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAgBH;AAED,kCAAkC;AAClC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,QAwMzE;AAyBD,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,UAAU,CAW5F;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,eAAe,CAW9F"}
+{"version":3,"file":"device-parameters.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/device-parameters.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,eAAe,EAAgD,MAAM,eAAe,CAAC;AAClG,OAAO,EAAC,MAAM,EAAO,UAAU,EAA+B,MAAM,eAAe,CAAC;AAEpF,OAAO,KAAK,EAGV,UAAU,EACV,YAAY,EAIb,MAAM,oBAAoB,CAAC;AAO5B;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,GAAG,OAAO,EACnD,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAgBH;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,OAAO,EAC1C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,YAAY,EACxB,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAeH;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,GAAG,OAAO,EAC9C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAgBH;AAED,kCAAkC;AAClC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,QAwMzE;AAyBD,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,UAAU,CAW5F;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,eAAe,CAW9F"}

package/dist/adapter/converters/device-parameters.js

@@ -1,7 +1,7 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { log, isObjectEmpty } from '@luma.gl/core';
+import { log } from '@luma.gl/core';
 import { GL } from '@luma.gl/constants';
 import { pushContextState, popContextState } from "../../context/state-tracker/track-context-state.js";
 import { setGLParameters } from "../../context/parameters/unified-parameter-api.js";
@@ -328,3 +328,14 @@ function map(parameter, value, valueMap) {
 function mapBoolean(parameter, value) {
     return value;
 }
+/** Returns true if given object is empty, false otherwise. */
+function isObjectEmpty(obj) {
+    let isEmpty = true;
+    // @ts-ignore key is unused
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    for (const key in obj) {
+        isEmpty = false;
+        break;
+    }
+    return isEmpty;
+}

package/dist/adapter/converters/texture-formats.d.ts

@@ -1,5 +1,5 @@
 import type { TextureFormat, DeviceFeature } from '@luma.gl/core';
-import { GL, GLExtensions } from '@luma.gl/constants';
+import { GL, GLPixelType, GLExtensions, GLTexelDataFormat } from '@luma.gl/constants';
 export declare const TEXTURE_FEATURES: Partial<Record<DeviceFeature, string[]>>;
 /** Return a list of texture feature strings (for Device.features). Mainly compressed texture support */
 export declare function isTextureFeature(feature: DeviceFeature): boolean;
@@ -27,8 +27,8 @@ type Format = {
     filter?: DeviceFeature;
     /** If not supported on WebGPU */
     wgpu?: false;
-    types?: number[];
-    dataFormat?: GL;
+    types?: GLPixelType[];
+    dataFormat?: GLTexelDataFormat;
     /** Depth and stencil format attachment points. If set, needs to be a Renderbuffer unless depthTexture is set  */
     attachment?: GL.DEPTH_ATTACHMENT | GL.STENCIL_ATTACHMENT | GL.DEPTH_STENCIL_ATTACHMENT;
     /** if depthTexture is set this is a depth/stencil format that can be set to a texture  */
@@ -44,14 +44,6 @@ export declare const TEXTURE_FORMATS: Record<TextureFormat, Format>;
 /** Checks if a texture format is supported */
 export declare function isTextureFormatSupported(gl: WebGL2RenderingContext, format: TextureFormat, extensions: GLExtensions): boolean;
 export declare function isRenderbufferFormatSupported(gl: WebGL2RenderingContext, format: TextureFormat, extensions: GLExtensions): boolean;
-/**
- * Map WebGL texture formats (GL constants) to WebGPU-style TextureFormat strings
- */
-export declare function convertGLToTextureFormat(format: GL | TextureFormat): TextureFormat;
-/**
- * Map WebGPU style texture format strings to GL constants
- */
-export declare function convertTextureFormatToGL(format: TextureFormat): GL | undefined;
 /** Checks if a texture format is supported */
 export declare function getTextureFormatSupport(gl: WebGL2RenderingContext, format: TextureFormat, extensions: GLExtensions): {
     supported: boolean;
@@ -64,14 +56,28 @@ export declare function getTextureFormatSupport(gl: WebGL2RenderingContext, form
 export declare function isTextureFormatFilterable(gl: WebGL2RenderingContext, format: TextureFormat, extensions: GLExtensions): boolean;
 export declare function isTextureFormatRenderable(gl: WebGL2RenderingContext, format: TextureFormat, extensions: GLExtensions): boolean;
 /** Get parameters necessary to work with format in WebGL: internalFormat, dataFormat, type, compressed, */
-export declare function getWebGLTextureParameters(format: TextureFormat): {
-    format: GL;
-    dataFormat: GL;
-    type: number;
-    compressed: any;
+export declare function getTextureFormatWebGL(format: TextureFormat): {
+    internalFormat: GL;
+    format: GLTexelDataFormat;
+    type: GLPixelType;
+    compressed: boolean;
 };
 export declare function getDepthStencilAttachmentWebGL(format: TextureFormat): GL.DEPTH_ATTACHMENT | GL.STENCIL_ATTACHMENT | GL.DEPTH_STENCIL_ATTACHMENT;
 /** TODO - VERY roundabout legacy way of calculating bytes per pixel */
 export declare function getTextureFormatBytesPerPixel(format: TextureFormat): number;
+export declare function getWebGLPixelDataFormat(dataFormat: string, integer: boolean, normalized: boolean, format: GL): GLTexelDataFormat;
 export {};
+/**
+ * Map WebGL texture formats (GL constants) to WebGPU-style TextureFormat strings
+export function convertGLToTextureFormat(format: GL | TextureFormat): TextureFormat {
+  if (typeof format === 'string') {
+    return format;
+  }
+  const entry = Object.entries(TEXTURE_FORMATS).find(([, entry]) => entry.gl === format);
+  if (!entry) {
+    throw new Error(`Unknown texture format ${format}`);
+  }
+  return entry[0] as TextureFormat;
+}
+ */
 //# sourceMappingURL=texture-formats.d.ts.map

package/dist/adapter/converters/texture-formats.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"texture-formats.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/texture-formats.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"texture-formats.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/texture-formats.ts"],"names":[],"mappings":"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"}

package/dist/adapter/converters/texture-formats.js

@@ -123,7 +123,6 @@ export const TEXTURE_FORMATS = {
     'bgra8unorm-srgb': { b: 4, c: 4 },
     'rg16uint': { gl: 33338, b: 4, c: 1, bpp: 4 },
     'rg16sint': { gl: 33337, b: 4, c: 2, bpp: 4 },
-    // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension
     'rg16float': { gl: 33327, bpp: 4, b: 4, c: 2, render: float16_renderable, filter: float16_filterable, rb: true },
     'rg16unorm-webgl': { gl: 33324, b: 2, c: 2, render: norm16_renderable },
     'rg16snorm-webgl': { gl: 36761, b: 2, c: 2, render: snorm16_renderable },
@@ -380,31 +379,7 @@ export function isTextureFormatSupported(gl, format, extensions) {
 }
 export function isRenderbufferFormatSupported(gl, format, extensions) {
     // Note: Order is important since the function call initializes extensions.
-    return isTextureFormatSupported(gl, format, extensions) && TEXTURE_FORMATS[format]?.rb;
-}
-/**
- * Map WebGL texture formats (GL constants) to WebGPU-style TextureFormat strings
- */
-export function convertGLToTextureFormat(format) {
-    if (typeof format === 'string') {
-        return format;
-    }
-    const entry = Object.entries(TEXTURE_FORMATS).find(([, entry]) => entry.gl === format);
-    if (!entry) {
-        throw new Error(`Unknown texture format ${format}`);
-    }
-    return entry[0];
-}
-/**
- * Map WebGPU style texture format strings to GL constants
- */
-export function convertTextureFormatToGL(format) {
-    const formatInfo = TEXTURE_FORMATS[format];
-    const webglFormat = formatInfo?.gl;
-    if (webglFormat === undefined) {
-        throw new Error(`Unsupported texture format ${format}`);
-    }
-    return webglFormat;
+    return isTextureFormatSupported(gl, format, extensions) && Boolean(TEXTURE_FORMATS[format]?.rb);
 }
 /** Checks if a texture format is supported */
 export function getTextureFormatSupport(gl, format, extensions) {
@@ -470,13 +445,13 @@ export function isTextureFormatRenderable(gl, format, extensions) {
     return true;
 }
 /** Get parameters necessary to work with format in WebGL: internalFormat, dataFormat, type, compressed, */
-export function getWebGLTextureParameters(format) {
+export function getTextureFormatWebGL(format) {
     const formatData = TEXTURE_FORMATS[format];
     const webglFormat = convertTextureFormatToGL(format);
     const decoded = decodeTextureFormat(format);
     return {
-        format: webglFormat,
-        dataFormat: formatData?.dataFormat ||
+        internalFormat: webglFormat,
+        format: formatData?.dataFormat ||
             getWebGLPixelDataFormat(decoded.format, decoded.integer, decoded.normalized, webglFormat),
         // depth formats don't have a type
         type: decoded.dataType
@@ -496,14 +471,14 @@ export function getDepthStencilAttachmentWebGL(format) {
 /** TODO - VERY roundabout legacy way of calculating bytes per pixel */
 export function getTextureFormatBytesPerPixel(format) {
     // TODO remove webgl1 support
-    const params = getWebGLTextureParameters(format);
+    const params = getTextureFormatWebGL(format);
     // NOTE(Tarek): Default to RGBA bytes
-    const channels = DATA_FORMAT_CHANNELS[params.dataFormat] || 4;
+    const channels = DATA_FORMAT_CHANNELS[params.format] || 4;
     const channelSize = TYPE_SIZES[params.type] || 1;
     return channels * channelSize;
 }
 // DATA TYPE HELPERS
-function getWebGLPixelDataFormat(dataFormat, integer, normalized, format) {
+export function getWebGLPixelDataFormat(dataFormat, integer, normalized, format) {
     // WebGL1 formats use same internalFormat
     if (format === 6408 || format === 6407) {
         return format;
@@ -517,3 +492,27 @@ function getWebGLPixelDataFormat(dataFormat, integer, normalized, format) {
         default: return 6408;
     }
 }
+/**
+ * Map WebGPU style texture format strings to GL constants
+ */
+function convertTextureFormatToGL(format) {
+    const formatInfo = TEXTURE_FORMATS[format];
+    const webglFormat = formatInfo?.gl;
+    if (webglFormat === undefined) {
+        throw new Error(`Unsupported texture format ${format}`);
+    }
+    return webglFormat;
+}
+/**
+ * Map WebGL texture formats (GL constants) to WebGPU-style TextureFormat strings
+export function convertGLToTextureFormat(format: GL | TextureFormat): TextureFormat {
+  if (typeof format === 'string') {
+    return format;
+  }
+  const entry = Object.entries(TEXTURE_FORMATS).find(([, entry]) => entry.gl === format);
+  if (!entry) {
+    throw new Error(`Unknown texture format ${format}`);
+  }
+  return entry[0] as TextureFormat;
+}
+ */

package/dist/adapter/device-helpers/webgl-device-features.js

@@ -57,7 +57,7 @@ export class WebGLDeviceFeatures extends DeviceFeatures {
         return [];
     }
     has(feature) {
-        if (this.disabledFeatures[feature]) {
+        if (this.disabledFeatures?.[feature]) {
             return false;
         }
         // We have already tested this feature

package/dist/adapter/device-helpers/webgl-device-limits.js

@@ -42,6 +42,6 @@ export class WebGLDeviceLimits extends DeviceLimits {
         if (this.limits[parameter] === undefined) {
             this.limits[parameter] = this.gl.getParameter(parameter);
         }
-        return this.limits[parameter];
+        return this.limits[parameter] || 0;
     }
 }

package/dist/adapter/helpers/webgl-texture-utils.d.ts

@@ -0,0 +1,300 @@
+import type { ExternalImage } from '@luma.gl/core';
+import { GL, GLTextureTarget, GLTexelDataFormat, GLPixelType } from '@luma.gl/constants';
+import { TypedArray } from '@math.gl/types';
+export type WebGLSetTextureOptions = {
+    dimension: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
+    height: number;
+    width: number;
+    depth?: number;
+    level?: number;
+    glTarget: GLTextureTarget;
+    glInternalFormat: GL;
+    glFormat: GLTexelDataFormat;
+    glType: GLPixelType;
+    compressed?: boolean;
+    byteOffset?: number;
+    byteLength?: number;
+};
+/**
+ * @param {*} pixels, data -
+ *  null - create empty texture of specified format
+ *  Typed array - init from image data in typed array
+ *  Buffer|WebGLBuffer - (WEBGL2) init from image data in WebGLBuffer
+ *  HTMLImageElement|Image - Inits with content of image. Auto width/height
+ *  HTMLCanvasElement - Inits with contents of canvas. Auto width/height
+ *  HTMLVideoElement - Creates video texture. Auto width/height
+ *
+ * @param  x - xOffset from where texture to be updated
+ * @param  y - yOffset from where texture to be updated
+ * @param  width - width of the sub image to be updated
+ * @param  height - height of the sub image to be updated
+ * @param  level - mip level to be updated
+ * @param {GLenum} format - internal format of image data.
+ * @param {GLenum} type
+ *  - format of array (autodetect from type) or
+ *  - (WEBGL2) format of buffer or ArrayBufferView
+ * @param {GLenum} dataFormat - format of image data.
+ * @param {Number} offset - (WEBGL2) offset from start of buffer
+ * @parameters - temporary settings to be applied, can be used to supply pixel store settings.
+ */
+export type WebGLCopyTextureOptions = {
+    dimension: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
+    level?: number;
+    height: number;
+    width: number;
+    depth?: number;
+    x?: number;
+    y?: number;
+    z?: number;
+    glTarget: GLTextureTarget;
+    glInternalFormat: GL;
+    glFormat: GL;
+    glType: GL;
+    compressed?: boolean;
+    byteOffset?: number;
+    byteLength?: number;
+};
+/**
+ * Initializes a texture memory space
+ * Clear all the textures and mip levels of a two-dimensional or array texture at the same time.
+ * On some implementations faster than repeatedly setting levels
+ *
+ * @note From WebGL 2 spec section 3.7.6:
+ * @see https://registry.khronos.org/webgl/specs/latest/2.0/
+ * - The image contents are set as if a buffer of sufficient size initialized to 0 would be passed to each level's texImage2D/3D
+ * - texStorage2D should be considered a preferred alternative to texImage2D. It may have lower memory costs than texImage2D in some implementations.
+ * - Once texStorage*D has been called, the texture is immutable and can only be updated with texSubImage*(), not texImage()
+ */
+export declare function initializeTextureStorage(gl: WebGL2RenderingContext, levels: number, options: WebGLSetTextureOptions): void;
+/**
+ * Copy a region of compressed data from a GPU memory buffer into this texture.
+ */
+export declare function copyCPUImageToMipLevel(gl: WebGL2RenderingContext, image: ExternalImage, options: WebGLCopyTextureOptions): void;
+/**
+ * Copy a region of data from a CPU memory buffer into this texture.
+ */
+export declare function copyCPUDataToMipLevel(gl: WebGL2RenderingContext, typedArray: TypedArray, options: WebGLCopyTextureOptions): void;
+/**
+ * Copy a region of compressed data from a GPU memory buffer into this texture.
+ */
+export declare function copyGPUBufferToMipLevel(gl: WebGL2RenderingContext, webglBuffer: WebGLBuffer, byteLength: number, options: WebGLCopyTextureOptions): void;
+/** Convert a WebGPU style texture constant to a WebGL style texture constant */
+export declare function getWebGLTextureTarget(dimension: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d'): GLTextureTarget;
+/**
+ * Clear a texture mip level.
+ * Wrapper for the messy WebGL texture API
+ *
+export function clearMipLevel(gl: WebGL2RenderingContext, options: WebGLSetTextureOptions): void {
+  const {dimension, width, height, depth = 0, level = 0} = options;
+  const {glInternalFormat, glFormat, glType, compressed} = options;
+  const glTarget = getCubeTargetWebGL(options.glTarget, dimension, depth);
+
+  switch (dimension) {
+    case '2d-array':
+    case '3d':
+      if (compressed) {
+        // prettier-ignore
+        gl.compressedTexImage3D(glTarget, level, glInternalFormat, width, height, depth, BORDER, null);
+      } else {
+        // prettier-ignore
+        gl.texImage3D( glTarget, level, glInternalFormat, width, height, depth, BORDER, glFormat, glType, null);
+      }
+      break;
+
+    case '2d':
+    case 'cube':
+      if (compressed) {
+        // prettier-ignore
+        gl.compressedTexImage2D(glTarget, level, glInternalFormat, width, height, BORDER, null);
+      } else {
+        // prettier-ignore
+        gl.texImage2D(glTarget, level, glInternalFormat, width, height, BORDER, glFormat, glType, null);
+      }
+      break;
+
+    default:
+      throw new Error(dimension);
+  }
+}
+
+/**
+ * Set a texture mip level to the contents of an external image.
+ * Wrapper for the messy WebGL texture API
+ * @note Corresponds to WebGPU device.queue.copyExternalImageToTexture()
+ *
+export function setMipLevelFromExternalImage(
+  gl: WebGL2RenderingContext,
+  image: ExternalImage,
+  options: WebGLSetTextureOptions
+): void {
+  const {dimension, width, height, depth = 0, level = 0} = options;
+  const {glInternalFormat, glType} = options;
+
+  const glTarget = getCubeTargetWebGL(options.glTarget, dimension, depth);
+
+  // TODO - we can't change texture width (due to WebGPU limitations) -
+  // and the width/heigh of an external image is implicit, so why do we need to extract it?
+  // So what width height do we supply? The image size or the texture size?
+  // const {width, height} = Texture.getExternalImageSize(image);
+
+  switch (dimension) {
+    case '2d-array':
+    case '3d':
+      // prettier-ignore
+      gl.texImage3D(glTarget, level, glInternalFormat, width, height, depth, BORDER, glInternalFormat, glType, image);
+      break;
+
+    case '2d':
+    case 'cube':
+      // prettier-ignore
+      gl.texImage2D(glTarget, level, glInternalFormat, width, height, BORDER, glInternalFormat, glType, image);
+      break;
+
+    default:
+      throw new Error(dimension);
+  }
+}
+
+/**
+ * Set a texture mip level from CPU memory
+ * Wrapper for the messy WebGL texture API
+ * @note Not available (directly) in WebGPU
+ *
+export function setMipLevelFromTypedArray(
+  gl: WebGL2RenderingContext,
+  data: TypedArray,
+  parameters: {},
+  options: {
+    dimension: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
+    height: number;
+    width: number;
+    depth?: number;
+    level?: number;
+    offset?: number;
+    glTarget: GLTextureTarget;
+    glInternalFormat: GL;
+    glFormat: GL;
+    glType: GL;
+    compressed?: boolean;
+  }
+): void {
+  const {dimension, width, height, depth = 0, level = 0, offset = 0} = options;
+  const {glInternalFormat, glFormat, glType, compressed} = options;
+
+  const glTarget = getCubeTargetWebGL(options.glTarget, dimension, depth);
+
+  withGLParameters(gl, parameters, () => {
+    switch (dimension) {
+      case '2d-array':
+      case '3d':
+        if (compressed) {
+          // prettier-ignore
+          gl.compressedTexImage3D(glTarget, level, glInternalFormat, width, height, depth, BORDER, data);
+        } else {
+          // prettier-ignore
+          gl.texImage3D( glTarget, level, glInternalFormat, width, height, depth, BORDER, glFormat, glType, data);
+        }
+        break;
+
+      case '2d':
+        if (compressed) {
+          // prettier-ignore
+          gl.compressedTexImage2D(glTarget, level, glInternalFormat, width, height, BORDER, data);
+        } else {
+          // prettier-ignore
+          gl.texImage2D( glTarget, level, glInternalFormat, width, height, BORDER, glFormat, glType, data, offset);
+        }
+        break;
+
+      default:
+        throw new Error(dimension);
+    }
+  });
+}
+
+/**
+   * Set a texture level from CPU memory
+   * @note Not available (directly) in WebGPU
+  _setMipLevelFromTypedArray(
+    depth: number,
+    level: number,
+    data: TextureLevelData,
+    offset = 0,
+    parameters
+  ): void {
+    withGLParameters(this.gl, parameters, () => {
+      switch (this.props.dimension) {
+        case '2d-array':
+        case '3d':
+          if (this.compressed) {
+            // prettier-ignore
+            this.device.gl.compressedTexImage3D(this.glTarget, level, this.glInternalFormat, data.width, data.height, depth, BORDER, data.data);
+          } else {
+            // prettier-ignore
+            this.gl.texImage3D( this.glTarget, level, this.glInternalFormat, this.width, this.height, depth, BORDER, this.glFormat, this.glType, data.data);
+          }
+          break;
+
+        case '2d':
+          if (this.compressed) {
+            // prettier-ignore
+            this.device.gl.compressedTexImage2D(this.glTarget, level, this.glInternalFormat, data.width, data.height, BORDER, data.data);
+          } else {
+            // prettier-ignore
+            this.device.gl.texImage2D( this.glTarget, level, this.glInternalFormat, this.width, this.height, BORDER, this.glFormat, this.glType, data.data, offset);
+          }
+          break;
+
+        default:
+          throw new Error(this.props.dimension);
+      }
+    });
+  }
+
+ * Set a texture level from a GPU buffer
+ *
+export function setMipLevelFromGPUBuffer(
+  gl: WebGL2RenderingContext,
+  buffer: Buffer,
+  options: WebGLSetTextureOptions
+): void {
+  const {dimension, width, height, depth = 0, level = 0, byteOffset = 0} = options;
+  const {glInternalFormat, glFormat, glType, compressed} = options;
+  const glTarget = getCubeTargetWebGL(options.glTarget, dimension, depth);
+
+  const webglBuffer = buffer as WEBGLBuffer;
+  const imageSize = buffer.byteLength;
+
+  // In WebGL the source buffer is not a parameter. Instead it needs to be bound to a special bind point
+  gl.bindBuffer(GL.PIXEL_UNPACK_BUFFER, webglBuffer.handle);
+
+  switch (dimension) {
+    case '2d-array':
+    case '3d':
+      if (compressed) {
+        // prettier-ignore
+        gl.compressedTexImage3D(glTarget, level, glInternalFormat, width, height, depth, BORDER, imageSize, byteOffset);
+      } else {
+        // prettier-ignore
+        gl.texImage3D(glTarget, level, glInternalFormat, width, height, depth, BORDER, glFormat, glType, byteOffset);
+      }
+      break;
+
+    case '2d':
+      if (compressed) {
+        // prettier-ignore
+        gl.compressedTexImage2D(glTarget, level, glInternalFormat, width, height, BORDER, imageSize, byteOffset);
+      } else {
+        // prettier-ignore
+        gl.texImage2D(glTarget, level, glInternalFormat, width, height, BORDER, glFormat, glType, byteOffset);
+      }
+      break;
+
+    default:
+      throw new Error(dimension);
+  }
+
+  gl.bindBuffer(GL.PIXEL_UNPACK_BUFFER, null);
+}
+*/
+//# sourceMappingURL=webgl-texture-utils.d.ts.map

package/dist/adapter/helpers/webgl-texture-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-texture-utils.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/webgl-texture-utils.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,eAAe,CAAC;AAEjD,OAAO,EACL,EAAE,EACF,eAAe,EAEf,iBAAiB,EACjB,WAAW,EACZ,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAC,UAAU,EAAC,MAAM,gBAAgB,CAAC;AAK1C,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,EAAE,IAAI,GAAG,IAAI,GAAG,UAAU,GAAG,MAAM,GAAG,YAAY,GAAG,IAAI,CAAC;IACnE,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,eAAe,CAAC;IAC1B,gBAAgB,EAAE,EAAE,CAAC;IACrB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC,SAAS,EAAE,IAAI,GAAG,IAAI,GAAG,UAAU,GAAG,MAAM,GAAG,YAAY,GAAG,IAAI,CAAC;IACnE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IAEX,QAAQ,EAAE,eAAe,CAAC;IAC1B,gBAAgB,EAAE,EAAE,CAAC;IACrB,QAAQ,EAAE,EAAE,CAAC;IACb,MAAM,EAAE,EAAE,CAAC;IACX,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CACtC,EAAE,EAAE,sBAAsB,EAC1B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,sBAAsB,GAC9B,IAAI,CAaN;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,sBAAsB,EAC1B,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,uBAAuB,GAC/B,IAAI,CAyBN;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,sBAAsB,EAC1B,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,uBAAuB,GAC/B,IAAI,CAgCN;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,sBAAsB,EAC1B,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,uBAAuB,GAC/B,IAAI,CAoCN;AAID,gFAAgF;AAChF,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,IAAI,GAAG,IAAI,GAAG,UAAU,GAAG,MAAM,GAAG,YAAY,GAAG,IAAI,GACjE,eAAe,CAWjB;AAgBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwNE"}