@luma.gl/core 9.0.0-alpha.9 → 9.0.0-beta.2

package/src/adapter/types/texture-formats.ts

@@ -0,0 +1,168 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+/** Texture formats */
+export type TextureFormat = ColorTextureFormat | DepthStencilTextureFormat;
+
+/** Depth and stencil texture formats */
+export type DepthStencilTextureFormat =
+  'stencil8' |
+  'depth16unorm' |
+  'depth24plus' |
+  'depth24plus-stencil8' |
+  'depth32float' |
+  // device.features.has('depth24unorm-stencil8')
+  'depth24unorm-stencil8' |
+  // device.features.has('depth32float-stencil8')
+  'depth32float-stencil8';
+
+/** Texture formats for color attachments */
+export type ColorTextureFormat = WebGPUColorTextureFormat | WebGL2ColorTextureFormat | UnsizedColorTextureFormat;
+
+export type WebGPUColorTextureFormat =
+  // 8-bit formats
+  'r8unorm' |
+  'r8snorm' |
+  'r8uint' |
+  'r8sint' |
+
+  // 16-bit formats
+  'r16uint' |
+  'r16sint' |
+  'r16float' |
+  'rg8unorm' |
+  'rg8snorm' |
+  'rg8uint' |
+  'rg8sint' |
+
+  // 32-bit formats
+  'r32uint' |
+  'r32sint' |
+  'r32float' |
+  'rg16uint' |
+  'rg16sint' |
+  'rg16float' |
+  'rgba8unorm' |
+  'rgba8unorm-srgb' |
+  'rgba8snorm' |
+  'rgba8uint' |
+  'rgba8sint' |
+  'bgra8unorm' |
+  'bgra8unorm-srgb' |
+  // Packed 32-bit formats
+  'rgb9e5ufloat' |
+  'rgb10a2unorm' |
+  'rg11b10ufloat' |
+
+  // 64-bit formats
+  'rg32uint' |
+  'rg32sint' |
+  'rg32float' |
+  'rgba16uint' |
+  'rgba16sint' |
+  'rgba16float' |
+
+  // 128-bit formats
+  'rgba32uint' |
+  'rgba32sint' |
+  'rgba32float' |
+
+  // BC compressed formats usable if 'texture-compression-bc' is both
+  // supported by the device/user agent and enabled in requestDevice.
+  'bc1-rgba-unorm' |
+  'bc1-rgba-unorm-srgb' |
+  'bc2-rgba-unorm' |
+  'bc2-rgba-unorm-srgb' |
+  'bc3-rgba-unorm' |
+  'bc3-rgba-unorm-srgb' |
+  'bc4-r-unorm' |
+  'bc4-r-snorm' |
+  'bc5-rg-unorm' |
+  'bc5-rg-snorm' |
+  'bc6h-rgb-ufloat' |
+  'bc6h-rgb-float' |
+  'bc7-rgba-unorm' |
+  'bc7-rgba-unorm-srgb' |
+
+  // ETC2 compressed formats usable if "texture-compression-etc2" is both
+  // supported by the device/user agent and enabled in requestDevice.
+  'etc2-rgb8unorm' |
+  'etc2-rgb8unorm-srgb' |
+  'etc2-rgb8a1unorm' |
+  'etc2-rgb8a1unorm-srgb' |
+  'etc2-rgba8unorm' |
+  'etc2-rgba8unorm-srgb' |
+  'eac-r11unorm' |
+  'eac-r11snorm' |
+  'eac-rg11unorm' |
+  'eac-rg11snorm' |
+
+  // ASTC compressed formats usable if "texture-compression-astc" is both
+  // supported by the device/user agent and enabled in requestDevice.
+  'astc-4x4-unorm' |
+  'astc-4x4-unorm-srgb' |
+  'astc-5x4-unorm' |
+  'astc-5x4-unorm-srgb' |
+  'astc-5x5-unorm' |
+  'astc-5x5-unorm-srgb' |
+  'astc-6x5-unorm' |
+  'astc-6x5-unorm-srgb' |
+  'astc-6x6-unorm' |
+  'astc-6x6-unorm-srgb' |
+  'astc-8x5-unorm' |
+  'astc-8x5-unorm-srgb' |
+  'astc-8x6-unorm' |
+  'astc-8x6-unorm-srgb' |
+  'astc-8x8-unorm' |
+  'astc-8x8-unorm-srgb' |
+  'astc-10x5-unorm' |
+  'astc-10x5-unorm-srgb' |
+  'astc-10x6-unorm' |
+  'astc-10x6-unorm-srgb' |
+  'astc-10x8-unorm' |
+  'astc-10x8-unorm-srgb' |
+  'astc-10x10-unorm' |
+  'astc-10x10-unorm-srgb' |
+  'astc-12x10-unorm' |
+  'astc-12x10-unorm-srgb' |
+  'astc-12x12-unorm' |
+  'astc-12x12-unorm-srgb'
+  ;
+
+/** Unsized texture formats (the only formats supported by WebGL1) */
+export type UnsizedColorTextureFormat =
+  // 'r8unorm-unsized' |
+  // 'ra8unorm-unsized' |
+  'rgb8unorm-unsized' |
+  'rgba8unorm-unsized'
+  // 'rgb8unorm-srgb-unsized' |
+  // 'rgba8unorm-srgb-unsized'
+  ;
+
+/** Sized formats unique to WebGL 2. Will perhaps be added to WebGPU? */
+export type WebGL2ColorTextureFormat =
+  'r16unorm-webgl' |
+  'r16snorm-webgl' |
+  'rgba4unorm-webgl' |
+  'rgb565unorm-webgl' |
+  'rgb5a1unorm-webgl' |
+  'rgb8unorm-webgl' |
+  'rgb8snorm-webgl' |
+  'rg16unorm-webgl' |
+  'rg16snorm-webgl' |
+  'rgb10a2unorm-webgl' |
+  'rgb16unorm-webgl' |
+  'rgb16snorm-webgl' |
+  'rgba16unorm-webgl' |
+  'rgba16snorm-webgl' |
+  'rgb32float-webgl' |
+  'bc1-rgb-unorm-webgl' |
+  'bc1-rgb-unorm-srgb-webgl' |
+  'pvrtc-rgb4unorm-webgl' |
+  'pvrtc-rgba4unorm-webgl' |
+  'pvrtc-rbg2unorm-webgl' |
+  'pvrtc-rgba2unorm-webgl' |
+  'etc1-rbg-unorm-webgl' |
+  'atc-rgb-unorm-webgl' |
+  'atc-rgba-unorm-webgl' |
+  'atc-rgbai-unorm-webgl';

package/src/adapter/types/types.ts

@@ -0,0 +1,109 @@
+// luma.gl, MIT license
+import {NumberArray} from '../../types';
+import type {ColorTextureFormat, DepthStencilTextureFormat, TextureFormat} from './texture-formats';
+import type {Buffer} from '../resources/buffer';
+import type {Texture} from '../resources/texture'; // TextureView...
+
+// UNIFORMS
+
+/** Valid values for uniforms. @note boolean values get converted to 0 or 1 before setting */
+export type UniformValue = number | boolean | Readonly<NumberArray>; // Float32Array> | Readonly<Int32Array> | Readonly<Uint32Array> | Readonly<number[]>;
+
+// BINDINGS
+
+/** Buffer bindings */
+export type Binding = Texture | Buffer | {buffer: Buffer,  offset?: number, size?: number};
+
+// BINDING LAYOUTS
+
+/** Describes a buffer binding layout */
+type BufferBindingLayout = {
+  /** The index of the binding point in the compiled and linked shader */
+  location?: number;
+  visibility: number;
+  /** type of buffer */
+  type: 'uniform' | 'storage' | 'read-only-storage';
+  hasDynamicOffset?: boolean;
+  minBindingSize?: number;
+}
+
+/** Describes a texture binding */
+type TextureBindingLayout = {
+  /** The index of the binding point in the compiled and linked shader */
+  location?: number;
+  visibility: number;
+  viewDimension?: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
+  sampleType?: 'float' | 'unfilterable-float' | 'depth' | 'sint' | 'uint';
+  multisampled?: boolean;
+};
+
+/** Describes a storage texture binding */
+type StorageTextureBindingLayout = {
+  /** The index of the binding point in the compiled and linked shader */
+  location?: number;
+  visibility: number;
+  access?: 'write-only';
+  format: TextureFormat;
+  viewDimension?: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
+};
+
+export type BindingDeclaration = BufferBindingLayout | TextureBindingLayout | StorageTextureBindingLayout;
+
+// TEXTURE VIEWS
+
+export type TextureView = {
+  texture: WebGLTexture;
+  layer?: number; //  = 0
+  level?: number; // = 0
+};
+
+// ATTACHMENTS (See Framebuffer)
+
+/**
+ * Framebuffer attachments lets the user specify the textures that will be used for a RenderPass, 
+ * together with some additional options for how to clear.
+ */
+export type ColorAttachment = {
+  /** Describes the texture subresource that will be output to for this color attachment. */
+  texture?: Texture;
+  /** Format of the texture resource. Used to auto create texture if not supplied */
+  format?: ColorTextureFormat;
+  /* Describes the texture subresource that will receive  resolved output for this color attachment if multisampled. */
+  // resolveTarget?: GPUTextureView;
+
+  /** Value to clear to prior to executing the render pass. Default: [0, 0, 0, 0]. Ignored if loadOp is not "clear". */
+  clearValue?: number[];
+  /** load operation to perform on texture prior to executing the render pass. Default: 'clear'. */
+  loadOp?: 'load' | 'clear';
+  /** The store operation to perform on texture after executing the render pass. Default: 'store'. */
+  storeOp?: 'store' | 'discard';
+};
+
+/**
+ * Framebuffer attachments lets the user specify the depth stencil texture that will be used for a RenderPass, 
+ * together with some additional options for how to clear.
+ */
+export type DepthStencilAttachment = {
+  /** Describes the texture subresource that will be output to and read from for this depth/stencil attachment. */
+  texture?: Texture;
+  /** Format of the texture resource. Used to auto create texture if not supplied */
+  format?: DepthStencilTextureFormat;
+
+  /** Value to clear depth component to prior to executing the render pass, if depthLoadOp is "clear". 0.0-1.0. */
+  depthClearValue?: number;
+  /** Indicates load operation to perform on depth component prior to executing the render pass. Default 'clear'. */
+  depthLoadOp?: 'load' | 'clear';
+  /** Store operation to perform on depth component after executing the render pass. Default: 'store'. */
+  depthStoreOp?: 'store' | 'discard';
+  /** Indicates that the depth component is read only. */
+  depthReadOnly?: boolean;
+
+  /** Indicates value to clear stencil component to prior to executing the render pass, if stencilLoadOp is "clear". */
+  stencilClearValue?: number;
+  /** Indicates  load operation to perform on stencil component prior to executing the render pass. Prefer clearing. */
+  stencilLoadOp?: 'load' | 'clear';
+  /** Store operation to perform on stencil component after executing the render pass. */
+  stencilStoreOp?: 'store' | 'discard';
+  /** Indicates that the stencil component is read only. */
+  stencilReadOnly?: boolean;
+};

package/src/adapter/types/vertex-formats.ts

@@ -0,0 +1,91 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+/** Basic data types signed and unsigned integers, and floats, of varying sizes */
+export type DataType =
+  | 'uint8'
+  | 'sint8'
+  | 'uint16'
+  | 'sint16'
+  | 'uint32'
+  | 'sint32'
+  | 'float16'
+  | 'float32';
+
+/** Vertex and Pixel data types. Include normalized integers */
+export type NormalizedDataType =
+  | 'uint8'
+  | 'sint8'
+  | 'unorm8'
+  | 'snorm8'
+  | 'uint16'
+  | 'sint16'
+  | 'unorm16'
+  | 'snorm16'
+  | 'uint32'
+  | 'sint32'
+  // WebGPU does not support normalized 32 bit integer attributes...
+  // | 'unorm32'
+  // | 'snorm32'
+  | 'float32'
+  | 'float16'
+  ;
+
+/** Describes the type (without number of components) of a vertex format */
+export type VertexType = NormalizedDataType;
+
+/**
+ * Describes the memory format of a buffer that will be supplied to vertex attributes
+ * @note Must be compatible with the ShaderAttributeType of the shaders, see documentation.
+ * @note This is a superset of WebGPU vertex formats to allow foe some flexibility for WebGL only applications
+ * @todo Add device.isTextureFormatSupported() method?
+ */
+export type VertexFormat =
+  // 8 bit integers, note that only 16 bit aligned formats are supported in WebGPU (x2 and x4)
+  | 'uint8x2'
+  | 'uint8x4'
+  | 'sint8x2'
+  | 'sint8x4'
+  | 'unorm8-webgl'
+  | 'unorm8x2'
+  | 'unorm8x3-webgl'
+  | 'unorm8x4'
+  | 'snorm8-webgl'
+  | 'snorm8x2'
+  | 'snorm8x3-webgl'
+  | 'snorm8x4'
+  // 16 bit integers, note that only 32 bit aligned formats are supported in WebGPU (x2 and x4)
+  | 'uint16x2'
+  | 'uint16x4'
+  | 'sint16x2'
+  | 'sint16x4'
+  | 'unorm16x2'
+  | 'unorm16x4'
+  | 'snorm16x2'
+  | 'snorm16x4'
+  // 32 bit integers
+  | 'uint32'
+  | 'uint32x2'
+  | 'uint32x3'
+  | 'uint32x4'
+  | 'sint32'
+  | 'sint32x2'
+  | 'sint32x3'
+  | 'sint32x4'
+  // No normalized 32 bit integers in WebGPU...
+  // | 'unorm32'
+  // | 'unorm32x2'
+  // | 'unorm32x3'
+  // | 'unorm32x4'
+  // | 'snorm32'
+  // | 'snorm32x2'
+  // | 'snorm32x3'
+  // | 'snorm32x4'
+  // floats
+  | 'float16x2'
+  | 'float16x4'
+  | 'float32'
+  | 'float32x2'
+  | 'float32x3'
+  | 'float32x4'
+  ;

package/src/index.ts

@@ -1,105 +1,173 @@
 // luma.gl, MIT license
-// core module exports
+// Copyright (c) vis.gl contributors
 
-// UTILS: undocumented API for other luma.gl modules
-export {log, assert, uid} from '@luma.gl/api';
+export {VERSION} from './init';
 
-// CORE MODULE EXPORTS FOR LUMA.GL
+// GENERAL TYPES
+export type {ConstructorOf, PartialBy} from './types';
 
-// ENGINE
-export {Timeline} from '@luma.gl/engine';
+// NUMERIC TYPES - TODO: could be imported from @math.gl/types
+export type {TypedArray, TypedArrayConstructor, NumberArray, BigIntOrNumberArray} from './types';
 
-export {
-  ClassicAnimationLoop as AnimationLoop,
-  ClassicModel as Model,
-  Transform,
-  ProgramManager,
-  ClipSpace
-} from '@luma.gl/gltools';
+export {isTypedArray, isNumberArray} from './utils/is-array';
 
-export {
-  Geometry,
-  ConeGeometry,
-  CubeGeometry,
-  CylinderGeometry,
-  IcoSphereGeometry,
-  PlaneGeometry,
-  SphereGeometry,
-  TruncatedConeGeometry
-} from '@luma.gl/engine';
+// MAIN API ACCESS POINTS
+export {luma} from './lib/luma';
+
+export type {DeviceProps, DeviceLimits, DeviceInfo, DeviceFeature} from './adapter/device';
+export {Device} from './adapter/device';
+export type {CanvasContextProps} from './adapter/canvas-context';
+export {CanvasContext} from './adapter/canvas-context';
+
+// GPU RESOURCES
+export type {ResourceProps} from './adapter/resources/resource';
+export {Resource} from './adapter/resources/resource';
+export type {BufferProps} from './adapter/resources/buffer';
+export {Buffer} from './adapter/resources/buffer';
+export type {TextureProps, TextureData} from './adapter/resources/texture';
+export {Texture} from './adapter/resources/texture';
+export type {ExternalTextureProps} from './adapter/resources/external-texture';
+export {ExternalTexture} from './adapter/resources/external-texture';
+export type {ShaderProps} from './adapter/resources/shader';
+export {Shader} from './adapter/resources/shader';
+export type {SamplerProps, SamplerParameters} from './adapter/resources/sampler';
+export {Sampler} from './adapter/resources/sampler';
+export type {FramebufferProps} from './adapter/resources/framebuffer';
+export {Framebuffer} from './adapter/resources/framebuffer';
+
+export type {RenderPipelineProps} from './adapter/resources/render-pipeline';
+export {RenderPipeline} from './adapter/resources/render-pipeline';
+
+export type {ComputePipelineProps} from './adapter/resources/compute-pipeline';
+export {ComputePipeline} from './adapter/resources/compute-pipeline';
+export type {RenderPassProps} from './adapter/resources/render-pass';
+export {RenderPass} from './adapter/resources/render-pass';
+export type {ComputePassProps} from './adapter/resources/compute-pass';
+export {ComputePass} from './adapter/resources/compute-pass';
+export type {CommandEncoderProps} from './adapter/resources/command-encoder';
+export {CommandEncoder} from './adapter/resources/command-encoder';
+export type {CommandBufferProps} from './adapter/resources/command-buffer';
+export {CommandBuffer} from './adapter/resources/command-buffer';
+
+export type {VertexArrayProps} from './adapter/resources/vertex-array';
+export {VertexArray} from './adapter/resources/vertex-array';
+
+export type {BufferRange, TransformFeedbackProps} from './adapter/resources/transform-feedback';
+export {TransformFeedback} from './adapter/resources/transform-feedback';
+
+// API TYPES
+export type {AccessorObject} from './adapter/types/accessor';
+export type {
+  Parameters,
+  PrimitiveTopology,
+  IndexFormat,
+  CullMode,
+  FrontFace,
+  RasterizationParameters,
+  CompareFunction,
+  StencilOperation,
+  DepthStencilParameters,
+  BlendFactor,
+  BlendOperation,
+  ColorParameters,
+  MultisampleParameters,
+  RenderPassParameters,
+  RenderPipelineParameters
+} from './adapter/types/parameters';
+
+// MEMORY LAYOUT TYPES
+export type {VertexFormat, VertexType} from './adapter/types/vertex-formats';
+export type {
+  TextureFormat,
+  ColorTextureFormat,
+  DepthStencilTextureFormat
+} from './adapter/types/texture-formats';
+export type {
+  ShaderDataType,
+  ShaderAttributeType,
+  ShaderUniformType
+} from './adapter/types/shader-types';
 
-// TODO - the following exports will be removed in v9
+export type {ColorAttachment, DepthStencilAttachment} from './adapter/types/types';
 
-// WEBGL - importing from `@luma.gl/core` is deprecated
+export type {
+  ShaderLayout,
+  AttributeDeclaration,
+  BindingDeclaration,
+  Binding
+} from './adapter/types/shader-layout';
+export type {BufferLayout, BufferAttributeLayout} from './adapter/types/buffer-layout';
+export type {
+  // Deprecated, todo
+  AttributeBinding,
+  UniformBinding,
+  UniformBlockBinding,
+  VaryingBinding
+} from './adapter/types/shader-layout';
 
-// GLTOOLS
+export type {UniformValue} from './adapter/types/types';
+export {UniformBufferLayout} from './lib/uniforms/uniform-buffer-layout';
+export {UniformBlock} from './lib/uniforms/uniform-block';
+export {UniformStore} from './lib/uniforms/uniform-store';
+
+// TYPE UTILS
+export {decodeVertexFormat} from './adapter/type-utils/decode-vertex-format';
+export {decodeTextureFormat} from './adapter/type-utils/decode-texture-format';
+export {getDataTypeFromTypedArray, getTypedArrayFromDataType, getVertexFormatFromAttribute} from './adapter/type-utils/vertex-format-from-attribute';
+
+// SHADER TYPE UTILS
+export {decodeShaderUniformType} from './adapter/type-utils/decode-shader-types';
+export {decodeShaderAttributeType} from './adapter/type-utils/decode-attribute-type';
+
+// COMPILER LOG
+export type {CompilerMessage} from './lib/compiler-log/compiler-message';
+export {formatCompilerLog} from './lib/compiler-log/format-compiler-log';
+
+//
+export type {AttributeInfo} from './adapter/attribute-utils/get-attribute-from-layouts';
 export {
-  createGLContext,
-  instrumentGLContext,
-  FEATURES,
-  hasFeature,
-  hasFeatures
-} from '@luma.gl/gltools';
+  getAttributeInfosFromLayouts,
+  mergeShaderLayout
+} from './adapter/attribute-utils/get-attribute-from-layouts';
 
-import {luma} from '@luma.gl/api';
-/** @deprecated Use luma.stats */
-export const lumaStats = luma.stats;
+// GENERAL UTILS
 
+export {StatsManager} from './utils/stats-manager';
+export {assert} from './utils/assert';
+export {cast} from './utils/cast';
+export {log} from './utils/log';
+export {uid, isPowerOfTwo, isObjectEmpty} from './utils/utils';
+export {isUniformValue, splitUniformsAndBindings} from './lib/uniforms/uniform';
+export {formatValue} from './utils/format-value';
+export {stubRemovedMethods} from './utils/stub-methods';
+export {checkProps} from './utils/check-props';
 export {
-  isWebGL,
-  isWebGL2,
-  getParameters,
-  setParameters,
-  withParameters,
-  resetParameters,
-  cssToDeviceRatio,
-  cssToDevicePixels,
-  Buffer,
-  Program,
-  Framebuffer,
-  Renderbuffer,
-  Texture2D,
-  TextureCube,
-  clear,
-  readPixelsToArray,
-  readPixelsToBuffer,
-  cloneTextureFrom,
-  copyToTexture,
-  Texture3D,
-  TransformFeedback
-} from '@luma.gl/gltools';
-
-// SHADERTOOLS - importing from `@luma.gl/core` is deprecated
-
-import {
-  // HELPERS
-  normalizeShaderModule as normalizeShaderModuleDeprecated,
-  // SHADER MODULES
-  fp32 as fp32Deprecated,
-  fp64 as fp64Deprecated,
-  project as projectDeprecated,
-  dirlight as dirlightDeprecated,
-  picking as pickingDeprecated,
-  gouraudLighting as gouraudLightingDeprecated,
-  phongLighting as phongLightingDeprecated,
-  pbr as pbrDeprecated
-} from '@luma.gl/shadertools';
-
-/** @deprecated Import directly from `@luma.gl/shadertools` */
-export const normalizeShaderModule = normalizeShaderModuleDeprecated;
-/** @deprecated Import directly from `@luma.gl/shadertools` */
-export const fp32 = fp32Deprecated;
-/** @deprecated Import directly from `@luma.gl/shadertools` */
-export const fp64 = fp64Deprecated;
-/** @deprecated Import directly from `@luma.gl/shadertools` */
-export const project = projectDeprecated;
-/** @deprecated Import directly from `@luma.gl/shadertools` */
-export const dirlight = dirlightDeprecated;
-/** @deprecated Import directly from `@luma.gl/shadertools` */
-export const picking = pickingDeprecated;
-/** @deprecated Import directly from `@luma.gl/shadertools` */
-export const gouraudLighting = gouraudLightingDeprecated;
-/** @deprecated Import directly from `@luma.gl/shadertools` */
-export const phongLighting = phongLightingDeprecated;
-/** @deprecated Import directly from `@luma.gl/shadertools` */
-export const pbr = pbrDeprecated;
+  setPathPrefix,
+  loadFile,
+  loadImage,
+  loadImageBitmap,
+  loadScript
+} from './utils/load-file';
+export {getScratchArrayBuffer, getScratchArray, fillArray} from './utils/array-utils-flat';
+export {makeRandomNumberGenerator, random} from './utils/random';
+export {deepEqual} from './utils/deep-equal';
+
+// ENGINE - TODO/move to @luma.gl/engine once that module is webgl-independent?
+export {requestAnimationFrame, cancelAnimationFrame} from './utils/request-animation-frame';
+
+// SHADER HELPERS
+
+/**
+ * Marks GLSL shaders for syntax highlighting: glsl`...`
+ * Install https://marketplace.visualstudio.com/items?itemName=boyswan.glsl-literal
+ */
+export const glsl = (x: TemplateStringsArray) => `${x}`;
+
+// INTERNAL
+
+export type {
+  CopyBufferToBufferOptions,
+  CopyBufferToTextureOptions,
+  CopyTextureToBufferOptions,
+  CopyTextureToTextureOptions
+} from './adapter/resources/command-encoder';

package/src/init.ts

@@ -0,0 +1,47 @@
+import {isBrowser} from '@probe.gl/env';
+import {log} from './utils/log';
+import {lumaStats} from './utils/stats-manager';
+
+declare global {
+  // eslint-disable-next-line no-var
+  var luma: any
+}
+
+/** 
+ * By adding the result of init() to Device.VERSION we guarantee it will be called
+ * @returns version
+ */
+function initializeLuma(): string {
+  // Version detection using babel plugin
+  // @ts-expect-error
+  const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'running from 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) {
+    if (isBrowser()) {
+      log.log(1, `${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,
+    };
+  }
+
+  return VERSION;
+}
+
+export const VERSION = initializeLuma();