@luma.gl/webgl 8.6.0-alpha.5 → 9.0.0-alpha.4

package/src/index.ts

@@ -5,71 +5,35 @@
 // Higher level abstractions can be built on these classes
 
 // Initialize any global state
-import './init';
+import '@luma.gl/api';
+import './init'
+
+export {default as WebGLDevice} from './adapter/webgl-device';
+export {default as WebGLCanvasContext} from './adapter/webgl-canvas-context';
+
+// Legacy WebGL Classes - will be moved to gltools
+export {default as Accessor} from './classic/accessor';
+export type {ClassicBufferProps as BufferProps} from './classic/buffer';
+export {default as Buffer} from './classic/buffer';
+export {default as WEBGLResource, default as WebGLResource} from './adapter/objects/webgl-resource';
+export {default as WEBGLBuffer} from './adapter/resources/webgl-buffer';
+export {default as WEBGLTexture} from './adapter/resources/webgl-texture';
+// export {default as WEBGLExternalTexture} from './adapter/resources/webgl-external-texture';
+export {default as WEBGLShader} from './adapter/resources/webgl-shader';
+export {default as WEBGLSampler} from './adapter/resources/webgl-sampler';
+export {default as WEBGLFramebuffer} from './adapter/resources/webgl-framebuffer';
+
+export {default as WEBGLRenderPipeline} from './adapter/resources/webgl-render-pipeline';
+
+// export {default as WEBGLComputePipeline} from './adapter/resources/webgl-compute-pipeline';
+export {default as WEBGLCommandEncoder} from './adapter/resources/webgl-command-encoder';
+export {default as WEBGLRenderPass} from './adapter/resources/webgl-render-pass';
+//export {default as WEBGLComputePass} from './adapter/resources/webgl-compute-pass';
+
+export type {RenderbufferProps} from './adapter/objects/webgl-renderbuffer';
+export {default as WEBGLRenderbuffer} from './adapter/objects/webgl-renderbuffer';
+export {default as WEBGLVertexArrayObject} from './adapter/objects/webgl-vertex-array-object';
 
-// export type {WebGLDeviceProps, WebGLDeviceInfo, WebGPUDeviceLimits} from './lib/webgl-device';
-export type {WebGLDeviceProps} from './adapter/webgl-device';
-export {default as WebGLDevice, getWebGLDevice} from './adapter/webgl-device';
-
-// UTILS
-export {requestAnimationFrame, cancelAnimationFrame} from './webgl-utils/request-animation-frame';
-
-// WebGL Functions
-export {cloneTextureFrom} from './webgl-utils/texture-utils';
-export {getKeyValue, getKey} from './webgl-utils/constants-to-keys';
-
-// WebGL Helper Classes
-export {default as Accessor} from './classes/accessor';
-
-// WebGL1 classes
-export type {BufferProps} from '@luma.gl/api';
-export {default as Buffer} from './classes/webgl-buffer';
-export type {Texture2DProps} from './classes/texture-2d';
-export {default as Texture2D} from './classes/texture-2d';
-export type {TextureCubeProps} from './classes/texture-cube';
-export {default as TextureCube} from './classes/texture-cube';
-
-export type {ProgramProps} from './classes/program';
-export {default as Program} from './classes/program';
-export type {FramebufferProps} from './classes/framebuffer';
-export {default as Framebuffer} from './classes/framebuffer';
-export type {RenderbufferProps} from './classes/renderbuffer';
-export {default as Renderbuffer} from './classes/renderbuffer';
-
-// Classic luma.gl classes (For backwards compatibility)
-export type {ShaderProps} from './classes/shader';
-export {Shader, VertexShader, FragmentShader} from './classes/shader';
-
-export {clear, clearBuffer} from './classes/clear';
-
-// Copy and Blit
-export {
-  readPixelsToArray,
-  readPixelsToBuffer,
-  copyToDataUrl,
-  copyToImage,
-  copyToTexture,
-  blit
-} from './classes/copy-and-blit';
-
-// WebGL2 classes & Extensions
-export type {QueryProps} from './classes/query';
-export {default as Query} from './classes/query';
-export type {Texture3DProps} from './classes/texture-3d';
-export {default as Texture3D} from './classes/texture-3d';
-export type {TransformFeedbackProps} from './classes/transform-feedback';
-export {default as TransformFeedback} from './classes/transform-feedback';
-export type {VertexArrayObjectProps} from './classes/vertex-array-object';
-export {default as VertexArrayObject} from './classes/vertex-array-object';
-export type {VertexArrayProps} from './classes/vertex-array';
-export {default as VertexArray} from './classes/vertex-array';
-export {default as UniformBufferLayout} from './classes/uniform-buffer-layout';
-
-export {setDeviceParameters} from './adapter/converters/set-device-parameters';
-
-// experimental WebGL exports
-
-// UTILS
 export {
   isWebGL,
   isWebGL2,
@@ -83,7 +47,9 @@ export {cssToDeviceRatio, cssToDevicePixels} from './context/context/device-pixe
 
 // Unified parameter API
 
-export type {GLParameters} from './context/parameters/webgl-parameters';
+export {setDeviceParameters, withDeviceParameters} from './adapter/converters/device-parameters';
+
+export type {GLParameters} from './types/webgl';
 export {
   getParameters,
   setParameters,
@@ -104,41 +70,6 @@ export {
 // Polyfills (supports a subset of WebGL2 APIs on WebGL1 contexts)
 export {polyfillContext} from './context/polyfill/polyfill-context';
 
-// INTERNAL
-export {parseUniformName, getUniformSetter} from './classes/uniforms';
-export {getDebugTableForUniforms} from './debug/debug-uniforms';
-export {getDebugTableForVertexArray} from './debug/debug-vertex-array';
-export {getDebugTableForProgramConfiguration} from './debug/debug-program-configuration';
-
 // HELPERS - EXPERIMENTAL
-export {getProgramBindings} from './helpers/get-program-bindings';
-
-// DEPRECATED
-
-// Deprecated re-exports
-export {lumaStats} from './init';
-export {log, assert, uid, isObjectEmpty} from '@luma.gl/api';
-export {setPathPrefix, loadFile, loadImage} from '@luma.gl/api';
-
-// GLTOOLS
-export type {GLContextOptions} from './_deprecated/context-api';
-export {
-  createGLContext,
-  instrumentGLContext,
-  resizeGLContext,
-  hasFeature,
-  hasFeatures,
-  getFeatures,
-  getContextInfo,
-  getGLContextInfo,
-  getContextLimits,
-  getContextDebugInfo
-} from './_deprecated/context-api';
-
-// Features
-export {DEPRECATED_FEATURES as FEATURES} from './_deprecated/features';
-
-// REMOVED in v8.7
-// getShaderInfo,
-// getShaderName
-// getShaderVersion
+export {getShaderLayout, getProgramBindings} from './adapter/helpers/get-shader-layout';
+export {_checkFloat32ColorAttachment} from './adapter/converters/texture-formats';

package/src/init.ts

@@ -1,48 +1,4 @@
-import {log} from '@luma.gl/api';
-import {isBrowser} from '@probe.gl/env';
-import {luma, lumaStats} from '@luma.gl/api';
+import {luma} from '@luma.gl/api';
 import WebGLDevice from './adapter/webgl-device';
 
-// Version detection using babel plugin
-// @ts-expect-error
-const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'untranspiled source';
-
-const STARTUP_MESSAGE = 'set luma.log.level=1 (or higher) to trace rendering';
-// Assign luma.log.level in console to control logging: \
-// 0: none, 1: minimal, 2: verbose, 3: attribute/uniforms, 4: gl logs
-// luma.log.break[], set to gl funcs, luma.log.profile[] set to model names`;
-
-if (globalThis.luma && globalThis.luma.VERSION !== VERSION) {
-  throw new Error(`luma.gl - multiple VERSIONs detected: ${globalThis.luma.VERSION} vs ${VERSION}`);
-}
-
-if (!globalThis.luma) {
-  luma.registerDevices([WebGLDevice]);
-
-  if (isBrowser()) {
-    log.log(1, `luma.gl ${VERSION} - ${STARTUP_MESSAGE}`)();
-  }
-
-  globalThis.luma = globalThis.luma || {
-    VERSION,
-    version: VERSION,
-    log,
-
-    // A global stats object that various components can add information to
-    // E.g. see webgl/resource.js
-    stats: lumaStats,
-
-    // Keep some luma globals in a sub-object
-    // This allows us to dynamically detect if certain modules have been
-    // included (such as IO and headless) and enable related functionality,
-    // without unconditionally requiring and thus bundling big dependencies
-    // into the app.
-    globals: {
-      modules: {},
-      nodeIO: {}
-    }
-  };
-}
-
-export {lumaStats};
-export default globalThis.luma;
+luma.registerDevices([WebGLDevice]);

package/src/types/webgl.ts

@@ -0,0 +1,283 @@
+import type {NumberArray} from '@luma.gl/api';
+import GL from '@luma.gl/constants';
+
+type Framebuffer = any;
+
+export type GLDrawMode =
+  | GL.POINTS
+  | GL.LINES
+  | GL.LINE_STRIP
+  | GL.LINE_LOOP
+  | GL.TRIANGLES
+  | GL.TRIANGLE_STRIP
+  | GL.TRIANGLE_FAN;
+
+export type GLPrimitive = GL.POINTS | GL.LINES | GL.TRIANGLES;
+
+export type GLType =
+  | GL.FLOAT
+  | GL.UNSIGNED_SHORT
+  | GL.UNSIGNED_INT
+  | GL.UNSIGNED_BYTE
+  | GL.BYTE
+  | GL.SHORT
+  | GL.INT;
+
+export type GLPackedType =
+  | GL.UNSIGNED_SHORT_5_6_5
+  | GL.UNSIGNED_SHORT_4_4_4_4
+  | GL.UNSIGNED_SHORT_5_5_5_1;
+
+export type GLUniformType = GLSamplerType | GLCompositeType;
+
+export type GLSamplerType =
+  | GL.SAMPLER_2D
+  | GL.SAMPLER_CUBE
+  | GL.SAMPLER_3D
+  | GL.SAMPLER_2D_SHADOW
+  | GL.SAMPLER_2D_ARRAY
+  | GL.SAMPLER_2D_ARRAY_SHADOW
+  | GL.SAMPLER_CUBE_SHADOW
+  | GL.INT_SAMPLER_2D
+  | GL.INT_SAMPLER_3D
+  | GL.INT_SAMPLER_CUBE
+  | GL.INT_SAMPLER_2D_ARRAY
+  | GL.UNSIGNED_INT_SAMPLER_2D
+  | GL.UNSIGNED_INT_SAMPLER_3D
+  | GL.UNSIGNED_INT_SAMPLER_CUBE
+  | GL.UNSIGNED_INT_SAMPLER_2D_ARRAY;
+
+// Composite types table
+export type GLCompositeType =
+  | GL.FLOAT
+  | GL.FLOAT_VEC2
+  | GL.FLOAT_VEC3
+  | GL.FLOAT_VEC4
+  | GL.INT
+  | GL.INT_VEC2
+  | GL.INT_VEC3
+  | GL.INT_VEC4
+  | GL.UNSIGNED_INT
+  | GL.UNSIGNED_INT_VEC2
+  | GL.UNSIGNED_INT_VEC3
+  | GL.UNSIGNED_INT_VEC4
+  | GL.BOOL
+  | GL.BOOL_VEC2
+  | GL.BOOL_VEC3
+  | GL.BOOL_VEC4
+  | GL.FLOAT_MAT2
+  | GL.FLOAT_MAT2x3
+  | GL.FLOAT_MAT2x4
+  | GL.FLOAT_MAT3x2
+  | GL.FLOAT_MAT3
+  | GL.FLOAT_MAT3x4
+  | GL.FLOAT_MAT4x2
+  | GL.FLOAT_MAT4x3
+  | GL.FLOAT_MAT4;
+
+export type GLFunction =
+  | GL.NEVER
+  | GL.LESS
+  | GL.EQUAL
+  | GL.LEQUAL
+  | GL.GREATER
+  | GL.NOTEQUAL
+  | GL.GEQUAL
+  | GL.ALWAYS;
+
+export type GLBlendEquation =
+  | GL.FUNC_ADD
+  | GL.FUNC_SUBTRACT
+  | GL.FUNC_REVERSE_SUBTRACT
+  | GL.MIN_EXT
+  | GL.MAX_EXT;
+
+export type GLBlendFunction =
+  | GL.ZERO
+  | GL.ONE
+  | GL.SRC_COLOR
+  | GL.ONE_MINUS_SRC_COLOR
+  | GL.DST_COLOR
+  | GL.ONE_MINUS_DST_COLOR
+  | GL.SRC_ALPHA
+  | GL.ONE_MINUS_SRC_ALPHA
+  | GL.DST_ALPHA
+  | GL.ONE_MINUS_DST_ALPHA
+  | GL.CONSTANT_COLOR
+  | GL.ONE_MINUS_CONSTANT_COLOR
+  | GL.CONSTANT_ALPHA
+  | GL.ONE_MINUS_CONSTANT_ALPHA
+  | GL.SRC_ALPHA_SATURATE;
+
+export type GLStencilOp =
+  | GL.KEEP
+  | GL.ZERO
+  | GL.REPLACE
+  | GL.INCR
+  | GL.INCR_WRAP
+  | GL.DECR
+  | GL.DECR_WRAP
+  | GL.INVERT;
+
+/** Parameters for textures and samplers */
+export type WebGLSamplerParameters = {
+  [GL.TEXTURE_WRAP_S]?: GL.CLAMP_TO_EDGE | GL.REPEAT | GL.MIRRORED_REPEAT;
+  [GL.TEXTURE_WRAP_T]?: GL.CLAMP_TO_EDGE | GL.REPEAT | GL.MIRRORED_REPEAT;
+  [GL.TEXTURE_WRAP_R]?: GL.CLAMP_TO_EDGE | GL.REPEAT | GL.MIRRORED_REPEAT;
+  [GL.TEXTURE_MAG_FILTER]?: GL.NEAREST | GL.LINEAR;
+  [GL.TEXTURE_MIN_FILTER]?:
+    | GL.NEAREST
+    | GL.LINEAR
+    | GL.NEAREST_MIPMAP_NEAREST
+    | GL.NEAREST_MIPMAP_LINEAR
+    | GL.LINEAR_MIPMAP_NEAREST
+    | GL.LINEAR_MIPMAP_LINEAR;
+  [GL.TEXTURE_MIN_LOD]?: number;
+  [GL.TEXTURE_MAX_LOD]?: number;
+  [GL.TEXTURE_COMPARE_FUNC]?: number; // COMPARE_FUNC);
+  [GL.TEXTURE_MAX_ANISOTROPY_EXT]?: number; //
+};
+
+/**
+ * All global WebGL values set by a variety of setter gl.enable ...
+ */
+export type GLValueParameters = {
+  [GL.BLEND]?: boolean;
+  [GL.BLEND_COLOR]?: [number, number, number, number] | NumberArray;
+  [GL.BLEND_EQUATION_RGB]?: GLBlendEquation;
+  [GL.BLEND_EQUATION_ALPHA]?: GLBlendEquation;
+  [GL.BLEND_SRC_RGB]?: GLBlendFunction;
+  [GL.BLEND_DST_RGB]?: GLBlendFunction;
+  [GL.BLEND_SRC_ALPHA]?: GLBlendFunction;
+  [GL.BLEND_DST_ALPHA]?: GLBlendFunction;
+  [GL.COLOR_CLEAR_VALUE]?: [number, number, number, number] | NumberArray;
+  [GL.COLOR_WRITEMASK]?: [boolean, boolean, boolean, boolean] | boolean[];
+  [GL.CULL_FACE]?: boolean;
+  [GL.CULL_FACE_MODE]?: GL.FRONT | GL.BACK | GL.FRONT_AND_BACK;
+  [GL.DEPTH_TEST]?: boolean;
+  [GL.DEPTH_CLEAR_VALUE]?: number;
+  [GL.DEPTH_FUNC]?: GLFunction;
+  [GL.DEPTH_RANGE]?: [number, number] | NumberArray;
+  [GL.DEPTH_WRITEMASK]?: boolean;
+  [GL.DITHER]?: boolean;
+  [GL.FRAGMENT_SHADER_DERIVATIVE_HINT]?: GL.FASTEST | GL.NICEST | GL.DONT_CARE;
+  [GL.CURRENT_PROGRAM]?: WebGLProgram | null;
+  [GL.FRAMEBUFFER_BINDING]?: WebGLFramebuffer | null;
+  [GL.RENDERBUFFER_BINDING]?: WebGLRenderbuffer | null;
+  [GL.TRANSFORM_FEEDBACK_BINDING]?: WebGLTransformFeedback | null;
+  [GL.VERTEX_ARRAY_BINDING]?: WebGLVertexArrayObject | null;
+  [GL.ARRAY_BUFFER_BINDING]?: WebGLBuffer | null;
+  [GL.COPY_READ_BUFFER_BINDING]?: WebGLBuffer | null;
+  [GL.COPY_WRITE_BUFFER_BINDING]?: WebGLBuffer | null;
+  [GL.PIXEL_PACK_BUFFER_BINDING]?: WebGLBuffer | null;
+  [GL.PIXEL_UNPACK_BUFFER_BINDING]?: WebGLBuffer | null;
+  [GL.TEXTURE_BINDING_2D]?: WebGLTexture | null;
+  [GL.TEXTURE_BINDING_2D_ARRAY]?: WebGLTexture | null;
+  [GL.TEXTURE_BINDING_3D]?: WebGLTexture | null;
+  [GL.TEXTURE_BINDING_CUBE_MAP]?: WebGLTexture | null;
+  [GL.FRONT_FACE]?: GL.CW | GL.CCW;
+  [GL.GENERATE_MIPMAP_HINT]?: GL.FASTEST | GL.NICEST | GL.DONT_CARE;
+  [GL.LINE_WIDTH]?: number;
+  [GL.POLYGON_OFFSET_FILL]?: boolean;
+  [GL.POLYGON_OFFSET_FACTOR]?: number;
+  [GL.POLYGON_OFFSET_UNITS]?: number;
+  [GL.SAMPLE_ALPHA_TO_COVERAGE]?: boolean;
+  [GL.SAMPLE_COVERAGE]?: boolean;
+  [GL.RASTERIZER_DISCARD]?: boolean;
+  [GL.SAMPLE_COVERAGE_VALUE]?: number;
+  [GL.SAMPLE_COVERAGE_INVERT]?: boolean;
+  [GL.SCISSOR_TEST]?: boolean;
+  [GL.SCISSOR_BOX]?: [number, number, number, number] | NumberArray;
+  [GL.STENCIL_TEST]?: boolean;
+  [GL.STENCIL_CLEAR_VALUE]?: number;
+  [GL.STENCIL_WRITEMASK]?: number;
+  [GL.STENCIL_BACK_WRITEMASK]?: number;
+  [GL.STENCIL_FUNC]?: GLFunction;
+  [GL.STENCIL_REF]?: GLFunction;
+  [GL.STENCIL_VALUE_MASK]?: GLFunction;
+  [GL.STENCIL_BACK_FUNC]?: GLFunction;
+  [GL.STENCIL_BACK_REF]?: GLFunction;
+  [GL.STENCIL_BACK_VALUE_MASK]?: GLFunction;
+  [GL.STENCIL_FAIL]?: GLStencilOp;
+  [GL.STENCIL_PASS_DEPTH_FAIL]?: GLStencilOp;
+  [GL.STENCIL_PASS_DEPTH_PASS]?: GLStencilOp;
+  [GL.STENCIL_BACK_FAIL]?: GLStencilOp;
+  [GL.STENCIL_BACK_PASS_DEPTH_FAIL]?: GLStencilOp;
+  [GL.STENCIL_BACK_PASS_DEPTH_PASS]?: GLStencilOp;
+  [GL.VIEWPORT]?: [number, number, number, number] | NumberArray;
+
+  // WEBGL1 PIXEL PACK/UNPACK MODES
+  [GL.PACK_ALIGNMENT]?: number;
+  [GL.UNPACK_ALIGNMENT]?: number;
+  [GL.UNPACK_FLIP_Y_WEBGL]?: boolean;
+  [GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]?: boolean;
+  [GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]?: GL.NONE | GL.BROWSER_DEFAULT_WEBGL;
+
+  // WEBGL2 PIXEL PACK/UNPACK MODES
+  // RASTERIZER_DISCARD ...
+  [GL.PACK_ROW_LENGTH]?: number;
+  [GL.PACK_SKIP_PIXELS]?: number;
+  [GL.PACK_SKIP_ROWS]?: number;
+  [GL.READ_FRAMEBUFFER_BINDING]?: Framebuffer | null;
+  [GL.UNPACK_ROW_LENGTH]?: number;
+  [GL.UNPACK_IMAGE_HEIGHT]?: number;
+  [GL.UNPACK_SKIP_PIXELS]?: number;
+  [GL.UNPACK_SKIP_ROWS]?: number;
+  [GL.UNPACK_SKIP_IMAGES]?: number;
+};
+
+export type GLFunctionParameters = {
+  // Function-style setters
+  framebuffer?: Framebuffer | null;
+  blend?: boolean;
+  blendColor?: [number, number, number, number] | NumberArray;
+  blendEquation?: GLBlendEquation | [GLBlendEquation, GLBlendEquation];
+  blendFunc?:
+    | [GLBlendFunction, GLBlendFunction]
+    | [GLBlendFunction, GLBlendFunction, GLBlendFunction, GLBlendFunction];
+
+  clearColor?: [number, number, number, number] | NumberArray;
+  clearDepth?: number;
+  clearStencil?: number;
+
+  colorMask?: [boolean, boolean, boolean, boolean];
+
+  cull?: boolean;
+  cullFace?: GL.FRONT | GL.BACK | GL.FRONT_AND_BACK;
+
+  depthTest?: boolean;
+  depthFunc?: GLFunction;
+  depthMask?: boolean;
+  depthRange?: [number, number] | NumberArray;
+
+  dither?: boolean;
+
+  derivativeHint?: GL.FASTEST | GL.NICEST | GL.DONT_CARE;
+
+  frontFace?: GL.CW | GL.CCW;
+
+  mipmapHint?: GL.FASTEST | GL.NICEST | GL.DONT_CARE;
+
+  lineWidth?: number;
+
+  polygonOffsetFill?: boolean;
+  polygonOffset?: [number, number];
+
+  sampleCoverage?: [number, boolean];
+
+  scissorTest?: boolean;
+  scissor?: [number, number, number, number] | NumberArray;
+
+  stencilTest?: boolean;
+  stencilMask?: number | [number, number];
+  stencilFunc?:
+    | [GLFunction, number, number]
+    | [GLFunction, number, number, GLFunction, number, number];
+  stencilOp?:
+    | [GLStencilOp, GLStencilOp, GLStencilOp]
+    | [GLStencilOp, GLStencilOp, GLStencilOp, GLStencilOp, GLStencilOp, GLStencilOp];
+  viewport?: [number, number, number, number] | NumberArray;
+};
+
+/** WebGL style parameters object (with both GL constants and function style fields) */
+export type GLParameters = GLValueParameters | GLFunctionParameters;

package/dist/_deprecated/context-api.d.ts

@@ -1,85 +0,0 @@
-import { WebGLDeviceProps } from '@luma.gl/webgl';
-export declare type GLContextOptions = WebGLDeviceProps & {
-    throwOnError?: boolean;
-};
-/** @deprecated Use `new WebGLDevice()` or `luma.createDevice()` */
-export declare function createGLContext(options?: GLContextOptions): WebGLRenderingContext | null;
-/** @deprecated Use `WebGLDevice.attach()` */
-export declare function instrumentGLContext(gl: WebGLRenderingContext | WebGL2RenderingContext, options?: GLContextOptions): WebGLRenderingContext;
-/**
- * Resize the canvas' drawing buffer.
- *
- * Can match the canvas CSS size, and optionally also consider devicePixelRatio
- * Can be called every frame
- *
- * Regardless of size, the drawing buffer will always be scaled to the viewport, but
- * for best visual results, usually set to either:
- *  canvas CSS width x canvas CSS height
- *  canvas CSS width * devicePixelRatio x canvas CSS height * devicePixelRatio
- * See http://webgl2fundamentals.org/webgl/lessons/webgl-resizing-the-canvas.html
- *
- * resizeGLContext(gl, {width, height, useDevicePixels})
- * @deprecated Use WebGLDevice.resize()
- */
-export declare function resizeGLContext(gl: WebGLRenderingContext, options?: {
-    width?: number;
-    height?: number;
-    useDevicePixels?: boolean | number;
-}): void;
-/**
- * Check one or more features
- * @deprecated Use `WebGLDevice.features.has()`
-*/
-export declare function hasFeatures(gl: WebGLRenderingContext, features: string | string[]): boolean;
-/**
- * Check one feature
- * @deprecated Use `WebGLDevice.features`
- */
-export declare function hasFeature(gl: WebGLRenderingContext, feature: string): boolean;
-/**
- * Return a map of supported features
- * @deprecated Use `WebGLDevice.features`
- */
-export declare function getFeatures(gl: WebGLRenderingContext): Record<string, boolean>;
-/**
- * Provides strings identifying the GPU vendor and driver.
- * https://www.khronos.org/registry/webgl/extensions/WEBGL_debug_renderer_info/
- *
- * @deprecated Use `WebGLDevice.info`
- */
-export declare function getContextDebugInfo(gl: WebGLRenderingContext): {
-    vendor: string;
-    renderer: string;
-    vendorMasked: string;
-    rendererMasked: string;
-    version: string;
-};
-/** @deprecated Use `WebGLDevice.info` */
-export declare function getGLContextInfo(gl: any): {
-    37445: string;
-    37446: string;
-    7936: string;
-    7937: string;
-    7938: string;
-};
-/** @deprecated Use `WebGLDevice.info` and `WebGLDevice.limits` */
-export declare function getContextInfo(gl: any): {
-    info: {
-        37445: string;
-        37446: string;
-        7936: string;
-        7937: string;
-        7938: string;
-    };
-    limits: import("../adapter/device-helpers/device-limits").WebGLLimits;
-    vendor: string;
-    renderer: string;
-    vendorMasked: string;
-    rendererMasked: string;
-    version: string;
-};
-/** @deprecated Use `WebGLDevice.limits` */
-export declare function getContextLimits(gl: any): {
-    limits: import("../adapter/device-helpers/device-limits").WebGLLimits;
-};
-//# sourceMappingURL=context-api.d.ts.map

package/dist/_deprecated/context-api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-api.d.ts","sourceRoot":"","sources":["../../src/_deprecated/context-api.ts"],"names":[],"mappings":"AAMA,OAAO,EAAc,gBAAgB,EAAC,MAAM,gBAAgB,CAAC;AAG7D,oBAAY,gBAAgB,GAAG,gBAAgB,GAAG;IAChD,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,mEAAmE;AACnE,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,qBAAqB,GAAG,IAAI,CAIxF;AAED,6CAA6C;AAC7C,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,qBAAqB,GAAG,sBAAsB,EAClD,OAAO,CAAC,EAAE,gBAAgB,GACzB,qBAAqB,CAGvB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,qBAAqB,EACzB,OAAO,CAAC,EAAE;IACR,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CACpC,QAIF;AAED;;;EAGE;AACF,wBAAgB,WAAW,CAAC,EAAE,EAAE,qBAAqB,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAM3F;AAUD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAE9E;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAQ9E;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,qBAAqB,GAAG;IAC9D,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB,CAQA;AAED,yCAAyC;AACzC,wBAAgB,gBAAgB,CAAC,EAAE,KAAA;;;;;;EASlC;AAED,kEAAkE;AAClE,wBAAgB,cAAc,CAAC,EAAE,KAAA;;;;;;;;;;;;;;EAMhC;AAED,2CAA2C;AAC3C,wBAAgB,gBAAgB,CAAC,EAAE,KAAA;;EAGlC"}

package/dist/_deprecated/context-api.js

@@ -1,76 +0,0 @@
-import GL from '@luma.gl/constants';
-import { WebGLDevice } from '@luma.gl/webgl';
-import { DEPRECATED_FEATURES } from './features';
-export function createGLContext(options) {
-  const webglDevice = new WebGLDevice(options);
-  return webglDevice.gl;
-}
-export function instrumentGLContext(gl, options) {
-  const webglDevice = WebGLDevice.attach(gl, options);
-  return webglDevice.gl;
-}
-export function resizeGLContext(gl, options) {
-  const webglDevice = WebGLDevice.attach(gl);
-  webglDevice.resize(options);
-}
-export function hasFeatures(gl, features) {
-  const webglDevice = WebGLDevice.attach(gl);
-  const normalizedFeatures = Array.isArray(features) ? features : [features];
-  const deviceFeatures = normalizedFeatures.map(feature => classicToDeviceFeature(feature));
-  return deviceFeatures.every(feature => webglDevice.features.has(feature));
-}
-
-function classicToDeviceFeature(feature) {
-  const deviceFeature = feature.toLowerCase().replace(/\_/g, '-');
-
-  if (deviceFeature.startsWith('webgl2') || deviceFeature.startsWith('glsl-')) {
-    return deviceFeature;
-  }
-
-  return "webgl-".concat(deviceFeature);
-}
-
-export function hasFeature(gl, feature) {
-  return hasFeatures(gl, feature);
-}
-export function getFeatures(gl) {
-  const webglDevice = WebGLDevice.attach(gl);
-  const featureMap = {};
-
-  for (const feature in DEPRECATED_FEATURES) {
-    featureMap[feature] = webglDevice.features.has(classicToDeviceFeature(feature));
-  }
-
-  return featureMap;
-}
-export function getContextDebugInfo(gl) {
-  const webglDevice = WebGLDevice.attach(gl);
-  const info = webglDevice.info;
-  return { ...webglDevice.info,
-    vendorMasked: webglDevice.info.vendor,
-    rendererMasked: webglDevice.info.renderer
-  };
-}
-export function getGLContextInfo(gl) {
-  const info = getContextDebugInfo(gl);
-  return {
-    [GL.UNMASKED_VENDOR_WEBGL]: info.vendor,
-    [GL.UNMASKED_RENDERER_WEBGL]: info.renderer,
-    [GL.VENDOR]: info.vendorMasked,
-    [GL.RENDERER]: info.rendererMasked,
-    [GL.VERSION]: info.version
-  };
-}
-export function getContextInfo(gl) {
-  return { ...getContextDebugInfo(gl),
-    ...getContextLimits(gl),
-    info: getGLContextInfo(gl)
-  };
-}
-export function getContextLimits(gl) {
-  const webglDevice = WebGLDevice.attach(gl);
-  return {
-    limits: webglDevice.webglLimits
-  };
-}
-//# sourceMappingURL=context-api.js.map

package/dist/_deprecated/context-api.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/_deprecated/context-api.ts"],"names":["GL","WebGLDevice","DEPRECATED_FEATURES","createGLContext","options","webglDevice","gl","instrumentGLContext","attach","resizeGLContext","resize","hasFeatures","features","normalizedFeatures","Array","isArray","deviceFeatures","map","feature","classicToDeviceFeature","every","has","deviceFeature","toLowerCase","replace","startsWith","hasFeature","getFeatures","featureMap","getContextDebugInfo","info","vendorMasked","vendor","rendererMasked","renderer","getGLContextInfo","UNMASKED_VENDOR_WEBGL","UNMASKED_RENDERER_WEBGL","VENDOR","RENDERER","VERSION","version","getContextInfo","getContextLimits","limits","webglLimits"],"mappings":"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","sourcesContent":["// luma.gl, MIT license\n// LEGACY luma.gl v8 API for WebGLRendering context\n// DEPRECATED API - may be removed in luma.gl v9 or v10.\n\n/* eslint-disable quotes */\nimport GL from '@luma.gl/constants';\nimport {WebGLDevice, WebGLDeviceProps} from '@luma.gl/webgl';\nimport {DEPRECATED_FEATURES} from './features';\n\nexport type GLContextOptions = WebGLDeviceProps & {\n  throwOnError?: boolean; // If set to false, return `null` if context creation fails.\n};\n\n/** @deprecated Use `new WebGLDevice()` or `luma.createDevice()` */\nexport function createGLContext(options?: GLContextOptions): WebGLRenderingContext | null {\n  const webglDevice = new WebGLDevice(options);\n  // Note: OK to return the context, it holds on to the device\n  return webglDevice.gl;\n}\n\n/** @deprecated Use `WebGLDevice.attach()` */\nexport function instrumentGLContext(\n  gl: WebGLRenderingContext | WebGL2RenderingContext,\n  options?: GLContextOptions\n): WebGLRenderingContext {\n  const webglDevice = WebGLDevice.attach(gl, options);\n  return webglDevice.gl;\n}\n\n/**\n * Resize the canvas' drawing buffer.\n *\n * Can match the canvas CSS size, and optionally also consider devicePixelRatio\n * Can be called every frame\n *\n * Regardless of size, the drawing buffer will always be scaled to the viewport, but\n * for best visual results, usually set to either:\n *  canvas CSS width x canvas CSS height\n *  canvas CSS width * devicePixelRatio x canvas CSS height * devicePixelRatio\n * See http://webgl2fundamentals.org/webgl/lessons/webgl-resizing-the-canvas.html\n *\n * resizeGLContext(gl, {width, height, useDevicePixels})\n * @deprecated Use WebGLDevice.resize()\n */\nexport function resizeGLContext(\n  gl: WebGLRenderingContext,\n  options?: {\n    width?: number;\n    height?: number;\n    useDevicePixels?: boolean | number;\n  }\n) {\n  const webglDevice = WebGLDevice.attach(gl);\n  webglDevice.resize(options);\n}\n\n/** \n * Check one or more features\n * @deprecated Use `WebGLDevice.features.has()`\n*/\nexport function hasFeatures(gl: WebGLRenderingContext, features: string | string[]): boolean {\n  const webglDevice = WebGLDevice.attach(gl);\n  const normalizedFeatures = Array.isArray(features) ? features : [features];\n  const deviceFeatures = normalizedFeatures.map(feature => classicToDeviceFeature(feature));\n  // @ts-expect-error Feature is a string enum\n  return deviceFeatures.every((feature) => webglDevice.features.has(feature));\n}\n\nfunction classicToDeviceFeature(feature: string): string {\n  const deviceFeature = feature.toLowerCase().replace(/\\_/g, '-');\n  if (deviceFeature.startsWith('webgl2') || deviceFeature.startsWith('glsl-')) {\n    return deviceFeature;\n  }\n  return `webgl-${deviceFeature}`;\n}\n\n/**\n * Check one feature\n * @deprecated Use `WebGLDevice.features`\n */\nexport function hasFeature(gl: WebGLRenderingContext, feature: string): boolean {\n  return hasFeatures(gl, feature);\n}\n\n/**\n * Return a map of supported features\n * @deprecated Use `WebGLDevice.features`\n */\nexport function getFeatures(gl: WebGLRenderingContext): Record<string, boolean>  {\n  const webglDevice = WebGLDevice.attach(gl);\n  const featureMap: Record<string, boolean> = {};\n  for (const feature in DEPRECATED_FEATURES) {\n    // @ts-expect-error Feature is a string enum\n    featureMap[feature] = webglDevice.features.has(classicToDeviceFeature(feature));\n  }\n  return featureMap;\n}\n\n/**\n * Provides strings identifying the GPU vendor and driver.\n * https://www.khronos.org/registry/webgl/extensions/WEBGL_debug_renderer_info/\n *\n * @deprecated Use `WebGLDevice.info`\n */\nexport function getContextDebugInfo(gl: WebGLRenderingContext): {\n  vendor: string;\n  renderer: string;\n  vendorMasked: string;\n  rendererMasked: string;\n  version: string;\n} {\n  const webglDevice = WebGLDevice.attach(gl);\n  const info = webglDevice.info;\n  return {\n    ...webglDevice.info,\n    vendorMasked: webglDevice.info.vendor,\n    rendererMasked: webglDevice.info.renderer\n  };\n}\n\n/** @deprecated Use `WebGLDevice.info` */\nexport function getGLContextInfo(gl) {\n  const info = getContextDebugInfo(gl);\n  return {\n    [GL.UNMASKED_VENDOR_WEBGL]: info.vendor,\n    [GL.UNMASKED_RENDERER_WEBGL]: info.renderer,\n    [GL.VENDOR]: info.vendorMasked,\n    [GL.RENDERER]: info.rendererMasked,\n    [GL.VERSION]: info.version,\n  };\n}\n\n/** @deprecated Use `WebGLDevice.info` and `WebGLDevice.limits` */\nexport function getContextInfo(gl) {\n  return {\n    ...getContextDebugInfo(gl),\n    ...getContextLimits(gl),\n    info: getGLContextInfo(gl),\n  };\n}\n\n/** @deprecated Use `WebGLDevice.limits` */\nexport function getContextLimits(gl) {\n  const webglDevice = WebGLDevice.attach(gl);\n  return {limits: webglDevice.webglLimits};\n}\n"],"file":"context-api.js"}