@aethervtt/shard-gpu-webgl2 0.0.0-stage → 0.2.0

package/dist/gl.js

@@ -0,0 +1,232 @@
+const GL = {
+  // Buffers
+  ARRAY_BUFFER: 34962,
+  ELEMENT_ARRAY_BUFFER: 34963,
+  UNIFORM_BUFFER: 35345,
+  COPY_READ_BUFFER: 36662,
+  COPY_WRITE_BUFFER: 36663,
+  PIXEL_PACK_BUFFER: 35051,
+  PIXEL_UNPACK_BUFFER: 35052,
+  STATIC_DRAW: 35044,
+  DYNAMIC_DRAW: 35048,
+  STREAM_READ: 35041,
+  DYNAMIC_READ: 35049,
+  // Types
+  BYTE: 5120,
+  UNSIGNED_BYTE: 5121,
+  SHORT: 5122,
+  UNSIGNED_SHORT: 5123,
+  INT: 5124,
+  UNSIGNED_INT: 5125,
+  FLOAT: 5126,
+  HALF_FLOAT: 5131,
+  UNSIGNED_INT_2_10_10_10_REV: 33640,
+  UNSIGNED_INT_10F_11F_11F_REV: 35899,
+  UNSIGNED_INT_24_8: 34042,
+  FLOAT_32_UNSIGNED_INT_24_8_REV: 36269,
+  // Formats
+  RED: 6403,
+  RG: 33319,
+  RGB: 6407,
+  RGBA: 6408,
+  RED_INTEGER: 36244,
+  RG_INTEGER: 33320,
+  RGBA_INTEGER: 36249,
+  DEPTH_COMPONENT: 6402,
+  DEPTH_STENCIL: 34041,
+  STENCIL_INDEX8: 36168,
+  // Internal formats
+  R8: 33321,
+  RG8: 33323,
+  RGBA8: 32856,
+  SRGB8_ALPHA8: 35907,
+  RGB10_A2: 32857,
+  R16F: 33325,
+  RG16F: 33327,
+  RGBA16F: 34842,
+  R32F: 33326,
+  RG32F: 33328,
+  RGBA32F: 34836,
+  R11F_G11F_B10F: 35898,
+  R8UI: 33330,
+  RGBA8UI: 36220,
+  R16UI: 33332,
+  R32UI: 33334,
+  RG32UI: 33340,
+  RGBA32UI: 36208,
+  DEPTH_COMPONENT16: 33189,
+  DEPTH_COMPONENT24: 33190,
+  DEPTH_COMPONENT32F: 36012,
+  DEPTH24_STENCIL8: 35056,
+  DEPTH32F_STENCIL8: 36013,
+  // Textures
+  TEXTURE_2D: 3553,
+  TEXTURE_2D_ARRAY: 35866,
+  TEXTURE_3D: 32879,
+  TEXTURE_CUBE_MAP: 34067,
+  TEXTURE_CUBE_MAP_POSITIVE_X: 34069,
+  TEXTURE0: 33984,
+  TEXTURE_BASE_LEVEL: 33084,
+  TEXTURE_MAX_LEVEL: 33085,
+  TEXTURE_MIN_FILTER: 10241,
+  TEXTURE_MAG_FILTER: 10240,
+  TEXTURE_WRAP_S: 10242,
+  TEXTURE_WRAP_T: 10243,
+  TEXTURE_WRAP_R: 32882,
+  TEXTURE_MIN_LOD: 33082,
+  TEXTURE_MAX_LOD: 33083,
+  TEXTURE_COMPARE_MODE: 34892,
+  TEXTURE_COMPARE_FUNC: 34893,
+  COMPARE_REF_TO_TEXTURE: 34894,
+  NONE: 0,
+  NEAREST: 9728,
+  LINEAR: 9729,
+  NEAREST_MIPMAP_NEAREST: 9984,
+  LINEAR_MIPMAP_NEAREST: 9985,
+  NEAREST_MIPMAP_LINEAR: 9986,
+  LINEAR_MIPMAP_LINEAR: 9987,
+  REPEAT: 10497,
+  CLAMP_TO_EDGE: 33071,
+  MIRRORED_REPEAT: 33648,
+  TEXTURE_MAX_ANISOTROPY_EXT: 34046,
+  MAX_TEXTURE_MAX_ANISOTROPY_EXT: 34047,
+  UNPACK_ALIGNMENT: 3317,
+  PACK_ALIGNMENT: 3333,
+  UNPACK_ROW_LENGTH: 3314,
+  UNPACK_IMAGE_HEIGHT: 32878,
+  UNPACK_SKIP_ROWS: 3315,
+  UNPACK_SKIP_PIXELS: 3316,
+  UNPACK_SKIP_IMAGES: 32877,
+  UNPACK_FLIP_Y_WEBGL: 37440,
+  UNPACK_PREMULTIPLY_ALPHA_WEBGL: 37441,
+  UNPACK_COLORSPACE_CONVERSION_WEBGL: 37443,
+  PACK_ROW_LENGTH: 3330,
+  // Framebuffers
+  FRAMEBUFFER: 36160,
+  READ_FRAMEBUFFER: 36008,
+  DRAW_FRAMEBUFFER: 36009,
+  RENDERBUFFER: 36161,
+  COLOR_ATTACHMENT0: 36064,
+  DEPTH_ATTACHMENT: 36096,
+  STENCIL_ATTACHMENT: 36128,
+  DEPTH_STENCIL_ATTACHMENT: 33306,
+  FRAMEBUFFER_COMPLETE: 36053,
+  COLOR_BUFFER_BIT: 16384,
+  DEPTH_BUFFER_BIT: 256,
+  STENCIL_BUFFER_BIT: 1024,
+  COLOR: 6144,
+  DEPTH: 6145,
+  STENCIL: 6146,
+  BACK: 1029,
+  SAMPLES: 32937,
+  // State
+  BLEND: 3042,
+  DITHER: 3024,
+  CULL_FACE: 2884,
+  DEPTH_TEST: 2929,
+  STENCIL_TEST: 2960,
+  SCISSOR_TEST: 3089,
+  POLYGON_OFFSET_FILL: 32823,
+  RASTERIZER_DISCARD: 35977,
+  FRONT: 1028,
+  FRONT_AND_BACK: 1032,
+  CW: 2304,
+  CCW: 2305,
+  NEVER: 512,
+  LESS: 513,
+  EQUAL: 514,
+  LEQUAL: 515,
+  GREATER: 516,
+  NOTEQUAL: 517,
+  GEQUAL: 518,
+  ALWAYS: 519,
+  KEEP: 7680,
+  ZERO: 0,
+  ONE: 1,
+  REPLACE: 7681,
+  INCR: 7682,
+  DECR: 7683,
+  INVERT: 5386,
+  INCR_WRAP: 34055,
+  DECR_WRAP: 34056,
+  SRC_COLOR: 768,
+  ONE_MINUS_SRC_COLOR: 769,
+  SRC_ALPHA: 770,
+  ONE_MINUS_SRC_ALPHA: 771,
+  DST_ALPHA: 772,
+  ONE_MINUS_DST_ALPHA: 773,
+  DST_COLOR: 774,
+  ONE_MINUS_DST_COLOR: 775,
+  SRC_ALPHA_SATURATE: 776,
+  CONSTANT_COLOR: 32769,
+  ONE_MINUS_CONSTANT_COLOR: 32770,
+  FUNC_ADD: 32774,
+  FUNC_SUBTRACT: 32778,
+  FUNC_REVERSE_SUBTRACT: 32779,
+  MIN: 32775,
+  MAX: 32776,
+  // Drawing
+  TRIANGLES: 4,
+  TRIANGLE_STRIP: 5,
+  LINES: 1,
+  LINE_STRIP: 3,
+  POINTS: 0,
+  // Shaders and programs
+  VERTEX_SHADER: 35633,
+  FRAGMENT_SHADER: 35632,
+  COMPILE_STATUS: 35713,
+  LINK_STATUS: 35714,
+  UNIFORM_BLOCK_DATA_SIZE: 35392,
+  COMPLETION_STATUS_KHR: 37297,
+  // Sync
+  SYNC_GPU_COMMANDS_COMPLETE: 37143,
+  SYNC_STATUS: 37140,
+  SIGNALED: 37145,
+  ALREADY_SIGNALED: 37146,
+  CONDITION_SATISFIED: 37148,
+  TIMEOUT_EXPIRED: 37147,
+  WAIT_FAILED: 37149,
+  // Limits
+  MAX_TEXTURE_SIZE: 3379,
+  MAX_3D_TEXTURE_SIZE: 32883,
+  MAX_ARRAY_TEXTURE_LAYERS: 35071,
+  MAX_CUBE_MAP_TEXTURE_SIZE: 34076,
+  MAX_TEXTURE_IMAGE_UNITS: 34930,
+  MAX_VERTEX_TEXTURE_IMAGE_UNITS: 35660,
+  MAX_COMBINED_TEXTURE_IMAGE_UNITS: 35661,
+  MAX_UNIFORM_BLOCK_SIZE: 35376,
+  MAX_VERTEX_UNIFORM_BLOCKS: 35371,
+  MAX_FRAGMENT_UNIFORM_BLOCKS: 35373,
+  MAX_COMBINED_UNIFORM_BLOCKS: 35374,
+  MAX_UNIFORM_BUFFER_BINDINGS: 35375,
+  UNIFORM_BUFFER_OFFSET_ALIGNMENT: 35380,
+  MAX_DRAW_BUFFERS: 34852,
+  MAX_COLOR_ATTACHMENTS: 36063,
+  MAX_VERTEX_ATTRIBS: 34921,
+  MAX_VARYING_COMPONENTS: 35659,
+  MAX_SAMPLES: 36183,
+  MAX_RENDERBUFFER_SIZE: 34024,
+  MAX_VERTEX_UNIFORM_VECTORS: 36347,
+  MAX_ELEMENT_INDEX: 36203,
+  // Errors
+  NO_ERROR: 0,
+  INVALID_ENUM: 1280,
+  INVALID_VALUE: 1281,
+  INVALID_OPERATION: 1282,
+  OUT_OF_MEMORY: 1285,
+  INVALID_FRAMEBUFFER_OPERATION: 1286,
+  CONTEXT_LOST_WEBGL: 37442,
+  // Debug info (WEBGL_debug_renderer_info)
+  UNMASKED_VENDOR_WEBGL: 37445,
+  UNMASKED_RENDERER_WEBGL: 37446,
+  VENDOR: 7936,
+  RENDERER: 7937
+};
+const CLIP = {
+  LOWER_LEFT_EXT: 36001,
+  ZERO_TO_ONE_EXT: 37727
+};
+export {
+  CLIP,
+  GL
+};

package/dist/gpu.d.ts

@@ -0,0 +1,58 @@
+import { type BakedTranslations } from './cache.js';
+import { type Webgl2AdapterInfo, Webgl2Device } from './device.js';
+import type { Naga } from './naga.js';
+export interface Webgl2GpuOptions {
+    /**
+     * The canvas whose context the device uses: it presents straight into it. Omitted, a detached
+     * canvas, and every surface is drawn onto from it.
+     */
+    canvas?: HTMLCanvasElement | OffscreenCanvas;
+    /** A context to use as it is (tests pass a fake one). */
+    context?: WebGL2RenderingContext;
+    /**
+     * 'minimum' holds the device to WebGL2's floor whatever the GPU has: no clip control, 16 texture
+     * units, 2048 texels, 4 draw buffers, no float filtering, no compression.
+     */
+    profile?: 'native' | 'minimum';
+    /** Checks GL errors after every submit. A round trip to the GPU process: for dev and tests. */
+    checkErrors?: boolean;
+    /**
+     * A baked translation set (`shard shaders bake`), fetched on the first pipeline: with every
+     * shader in it, naga never loads.
+     */
+    shaders?: string | URL | BakedTranslations;
+    /** Keeps translations in IndexedDB across sessions. Default true where there is IndexedDB. */
+    persist?: boolean;
+    /** Loads naga (tests count the loads). */
+    naga?: () => Promise<Naga>;
+}
+export interface Webgl2Gpu {
+    requestAdapter(options?: GPURequestAdapterOptions): Promise<Webgl2Adapter | null>;
+    getPreferredCanvasFormat(): GPUTextureFormat;
+    readonly wgslLanguageFeatures: ReadonlySet<string>;
+    /** Why the last requestAdapter found none: 'no-webgl2', 'context-lost' or 'no-float-render-targets'. */
+    readonly unavailable: string | undefined;
+}
+/** A WebGPU entry point over WebGL2 (0064). Installs the `GPU*` flag globals the engine reads. */
+export declare function createWebgl2Gpu(options?: Webgl2GpuOptions): Webgl2Gpu;
+/** Why WebGL2 can't run the baseline tier here, or undefined when it can. */
+export declare function webgl2Unavailable(gl: WebGL2RenderingContext | null): string | undefined;
+interface Opened {
+    gl: WebGL2RenderingContext;
+    canvas: HTMLCanvasElement | OffscreenCanvas | undefined;
+    owns: boolean;
+}
+export declare class Webgl2Adapter {
+    readonly features: ReadonlySet<string>;
+    readonly limits: Readonly<Record<string, number>>;
+    readonly info: Webgl2AdapterInfo;
+    readonly isFallbackAdapter = false;
+    readonly featureLevel = "compatibility";
+    private readonly caps;
+    private readonly extensions;
+    private readonly options;
+    private opened;
+    constructor(opened: Opened, options: Webgl2GpuOptions);
+    requestDevice(descriptor?: GPUDeviceDescriptor): Promise<Webgl2Device>;
+}
+export {};

package/dist/gpu.js

@@ -0,0 +1,215 @@
+import { Translator } from "./cache.js";
+import { installGpuConstants } from "./constants.js";
+import {
+  Webgl2Device
+} from "./device.js";
+import { GL } from "./gl.js";
+function createWebgl2Gpu(options = {}) {
+  installGpuConstants();
+  let unavailable;
+  return {
+    wgslLanguageFeatures: /* @__PURE__ */ new Set(),
+    get unavailable() {
+      return unavailable;
+    },
+    getPreferredCanvasFormat: () => "rgba8unorm",
+    requestAdapter(request) {
+      const opened = openContext(options, request?.powerPreference);
+      unavailable = typeof opened === "string" ? opened : void 0;
+      return Promise.resolve(typeof opened === "string" ? null : new Webgl2Adapter(opened, options));
+    }
+  };
+}
+function webgl2Unavailable(gl) {
+  if (!gl) return "no-webgl2";
+  if (gl.isContextLost()) return "context-lost";
+  if (!gl.getExtension("EXT_color_buffer_float")) return "no-float-render-targets";
+  return void 0;
+}
+function openContext(options, powerPreference) {
+  if (options.context) {
+    const why2 = webgl2Unavailable(options.context);
+    if (why2) return why2;
+    const canvas2 = options.canvas ?? options.context.canvas;
+    return { gl: options.context, canvas: canvas2, owns: false };
+  }
+  const canvas = options.canvas ?? detachedCanvas();
+  if (!canvas) return "no-webgl2";
+  const gl = canvas.getContext("webgl2", {
+    alpha: true,
+    antialias: false,
+    depth: false,
+    stencil: false,
+    premultipliedAlpha: true,
+    preserveDrawingBuffer: false,
+    powerPreference: powerPreference === "low-power" ? "low-power" : "high-performance"
+  });
+  const why = webgl2Unavailable(gl);
+  if (why) return why;
+  return { gl, canvas, owns: !options.canvas };
+}
+function detachedCanvas() {
+  const doc = globalThis.document;
+  if (doc) return doc.createElement("canvas");
+  if (typeof OffscreenCanvas !== "undefined") return new OffscreenCanvas(1, 1);
+  return void 0;
+}
+class Webgl2Adapter {
+  features;
+  limits;
+  info;
+  isFallbackAdapter = false;
+  featureLevel = "compatibility";
+  caps;
+  extensions;
+  options;
+  opened;
+  constructor(opened, options) {
+    this.opened = opened;
+    this.options = options;
+    const { caps, extensions } = capsOf(opened.gl, options.profile ?? "native");
+    this.caps = caps;
+    this.extensions = extensions;
+    this.features = featuresOf(opened.gl, caps, extensions.timer !== null);
+    this.limits = limitsOf(caps);
+    this.info = infoOf(opened.gl);
+  }
+  requestDevice(descriptor = {}) {
+    const missing = [...descriptor.requiredFeatures ?? []].filter((f) => !this.features.has(f));
+    if (missing.length > 0) {
+      return Promise.reject(new TypeError(`WebGL2 doesn't offer ${missing.join(", ")}`));
+    }
+    const opened = this.opened;
+    if (!opened) return Promise.reject(new Error("This adapter has already made its device"));
+    this.opened = void 0;
+    const caps = this.caps;
+    const device = new Webgl2Device(opened.gl, caps, {
+      label: descriptor.label,
+      canvas: opened.canvas,
+      ownsContext: opened.owns,
+      checkErrors: this.options.checkErrors === true,
+      features: new Set(descriptor.requiredFeatures ?? []),
+      limits: this.limits,
+      info: this.info,
+      translator: new Translator({
+        clipControl: caps.clipControl,
+        baked: this.options.shaders,
+        persist: this.options.persist,
+        naga: this.options.naga
+      }),
+      extensions: this.extensions
+    });
+    return Promise.resolve(device);
+  }
+}
+function capsOf(gl, profile) {
+  const minimum = profile === "minimum";
+  const ext = (name) => minimum ? null : gl.getExtension(name);
+  const p = (e) => gl.getParameter(e);
+  const anisotropic = ext("EXT_texture_filter_anisotropic");
+  const parallel = gl.getExtension("KHR_parallel_shader_compile");
+  const clipControl = ext("EXT_clip_control");
+  const floatBlend = gl.getExtension("EXT_float_blend");
+  const floatLinear = ext("OES_texture_float_linear");
+  const indexed = ext("OES_draw_buffers_indexed");
+  const lose = gl.getExtension("WEBGL_lose_context");
+  const timer = ext("EXT_disjoint_timer_query_webgl2");
+  const bc = ext("WEBGL_compressed_texture_s3tc") !== null && ext("WEBGL_compressed_texture_s3tc_srgb") !== null && ext("EXT_texture_compression_rgtc") !== null && ext("EXT_texture_compression_bptc") !== null;
+  const caps = {
+    maxSamples: minimum ? Math.min(4, p(GL.MAX_SAMPLES)) : p(GL.MAX_SAMPLES),
+    anisotropy: anisotropic ? p(GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1,
+    parallelCompile: parallel !== null,
+    textureUnits: minimum ? 16 : p(GL.MAX_TEXTURE_IMAGE_UNITS),
+    vertexTextureUnits: minimum ? 16 : p(GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
+    combinedUnits: minimum ? 32 : p(GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
+    clipControl: clipControl !== null,
+    floatBlend: floatBlend !== null,
+    floatLinear: floatLinear !== null,
+    maxTextureSize: minimum ? 2048 : p(GL.MAX_TEXTURE_SIZE),
+    max3dTextureSize: minimum ? 256 : p(GL.MAX_3D_TEXTURE_SIZE),
+    maxArrayLayers: minimum ? 256 : p(GL.MAX_ARRAY_TEXTURE_LAYERS),
+    maxCubeSize: minimum ? 2048 : p(GL.MAX_CUBE_MAP_TEXTURE_SIZE),
+    maxDrawBuffers: minimum ? 4 : Math.min(p(GL.MAX_DRAW_BUFFERS), p(GL.MAX_COLOR_ATTACHMENTS)),
+    maxAttributes: minimum ? 16 : p(GL.MAX_VERTEX_ATTRIBS),
+    maxVaryings: minimum ? 15 : Math.floor(p(GL.MAX_VARYING_COMPONENTS) / 4),
+    uniformBlockSize: minimum ? 16384 : p(GL.MAX_UNIFORM_BLOCK_SIZE),
+    uniformBlocks: minimum ? 12 : Math.min(p(GL.MAX_VERTEX_UNIFORM_BLOCKS), p(GL.MAX_FRAGMENT_UNIFORM_BLOCKS)),
+    uniformBindings: minimum ? 24 : p(GL.MAX_UNIFORM_BUFFER_BINDINGS),
+    uniformAlignment: p(GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT),
+    compression: {
+      bc,
+      astc: ext("WEBGL_compressed_texture_astc") !== null,
+      etc2: ext("WEBGL_compressed_texture_etc") !== null
+    }
+  };
+  return { caps, extensions: { clipControl, indexed, lose, timer } };
+}
+function featuresOf(gl, caps, timer) {
+  const features = /* @__PURE__ */ new Set(["depth32float-stencil8"]);
+  if (timer) features.add("timestamp-query");
+  if (caps.compression.bc) features.add("texture-compression-bc");
+  if (caps.compression.astc) features.add("texture-compression-astc");
+  if (caps.compression.etc2) features.add("texture-compression-etc2");
+  if (caps.floatLinear) features.add("float32-filterable");
+  if (caps.floatBlend) features.add("float32-blendable");
+  const samples = gl.getInternalformatParameter(
+    GL.RENDERBUFFER,
+    GL.R11F_G11F_B10F,
+    GL.SAMPLES
+  );
+  if (samples && samples.length > 0 && Math.max(...samples) >= 4)
+    features.add("rg11b10ufloat-renderable");
+  return features;
+}
+function limitsOf(caps) {
+  const sampled = Math.min(caps.textureUnits, caps.vertexTextureUnits);
+  return {
+    maxTextureDimension1D: caps.maxTextureSize,
+    maxTextureDimension2D: caps.maxTextureSize,
+    maxTextureDimension3D: caps.max3dTextureSize,
+    maxTextureArrayLayers: caps.maxArrayLayers,
+    maxBindGroups: 4,
+    maxBindGroupsPlusVertexBuffers: 24,
+    maxBindingsPerBindGroup: 1e3,
+    maxDynamicUniformBuffersPerPipelineLayout: 8,
+    maxDynamicStorageBuffersPerPipelineLayout: 0,
+    maxSampledTexturesPerShaderStage: sampled,
+    maxSamplersPerShaderStage: sampled,
+    maxStorageBuffersPerShaderStage: 0,
+    maxStorageBuffersInVertexStage: 0,
+    maxStorageBuffersInFragmentStage: 0,
+    maxStorageTexturesPerShaderStage: 0,
+    maxStorageTexturesInVertexStage: 0,
+    maxStorageTexturesInFragmentStage: 0,
+    maxUniformBuffersPerShaderStage: caps.uniformBlocks,
+    maxUniformBufferBindingSize: caps.uniformBlockSize,
+    maxStorageBufferBindingSize: 0,
+    minUniformBufferOffsetAlignment: Math.max(256, caps.uniformAlignment),
+    minStorageBufferOffsetAlignment: 256,
+    maxVertexBuffers: 8,
+    maxBufferSize: 256 * 1024 * 1024,
+    maxVertexAttributes: caps.maxAttributes,
+    // WebGL's vertexAttribPointer stride limit.
+    maxVertexBufferArrayStride: 255,
+    maxInterStageShaderVariables: caps.maxVaryings,
+    maxColorAttachments: caps.maxDrawBuffers,
+    maxColorAttachmentBytesPerSample: 32,
+    maxComputeWorkgroupStorageSize: 0,
+    maxComputeInvocationsPerWorkgroup: 0,
+    maxComputeWorkgroupSizeX: 0,
+    maxComputeWorkgroupSizeY: 0,
+    maxComputeWorkgroupSizeZ: 0,
+    maxComputeWorkgroupsPerDimension: 0
+  };
+}
+function infoOf(gl) {
+  const debug = gl.getExtension("WEBGL_debug_renderer_info");
+  const vendor = String(gl.getParameter(debug ? GL.UNMASKED_VENDOR_WEBGL : GL.VENDOR) ?? "");
+  const renderer = String(gl.getParameter(debug ? GL.UNMASKED_RENDERER_WEBGL : GL.RENDERER) ?? "");
+  return { vendor, architecture: "", device: renderer, description: `WebGL2: ${renderer}` };
+}
+export {
+  Webgl2Adapter,
+  createWebgl2Gpu,
+  webgl2Unavailable
+};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { type BakedTranslations, NAGA_VERSION, SHIM_VERSION, type ShaderCacheStats, Translator, type TranslatorOptions, translationKey, } from './cache.js';
+export { BufferUsage, ColorWrite, installGpuConstants, MapMode, ShaderStage, TextureUsage, } from './constants.js';
+export type { Webgl2AdapterInfo, Webgl2Caps, Webgl2Device } from './device.js';
+export { unsupported } from './errors.js';
+export { createWebgl2Gpu, type Webgl2Adapter, type Webgl2Gpu, type Webgl2GpuOptions, webgl2Unavailable, } from './gpu.js';
+export { type GlslStage, type GlslTranslation, loadNaga, type Naga, type TranslateOptions, } from './naga.js';
+export { entryPointOf } from './pipeline.js';
+export { canvasContext, type Webgl2CanvasContext } from './present.js';

package/dist/index.js

@@ -0,0 +1,42 @@
+import {
+  NAGA_VERSION,
+  SHIM_VERSION,
+  Translator,
+  translationKey
+} from "./cache.js";
+import {
+  BufferUsage,
+  ColorWrite,
+  installGpuConstants,
+  MapMode,
+  ShaderStage,
+  TextureUsage
+} from "./constants.js";
+import { unsupported } from "./errors.js";
+import {
+  createWebgl2Gpu,
+  webgl2Unavailable
+} from "./gpu.js";
+import {
+  loadNaga
+} from "./naga.js";
+import { entryPointOf } from "./pipeline.js";
+import { canvasContext } from "./present.js";
+export {
+  BufferUsage,
+  ColorWrite,
+  MapMode,
+  NAGA_VERSION,
+  SHIM_VERSION,
+  ShaderStage,
+  TextureUsage,
+  Translator,
+  canvasContext,
+  createWebgl2Gpu,
+  entryPointOf,
+  installGpuConstants,
+  loadNaga,
+  translationKey,
+  unsupported,
+  webgl2Unavailable
+};

package/dist/naga.d.ts

@@ -0,0 +1,37 @@
+export type GlslStage = 'vertex' | 'fragment';
+export interface GlslTranslation {
+    glsl: string;
+    /** Combined sampler uniforms: the texture binding, and the sampler's (null for `texelFetch`). */
+    textures: {
+        name: string;
+        group: number;
+        binding: number;
+        sampler: [number, number] | null;
+    }[];
+    /** Uniform blocks by block name. */
+    uniforms: {
+        name: string;
+        group: number;
+        binding: number;
+    }[];
+    varyings: {
+        name: string;
+        location: number;
+    }[];
+    /** Uses `naga_vs_first_instance`, the uniform standing in for the draw's first instance. */
+    firstInstance: boolean;
+}
+export interface TranslateOptions {
+    /**
+     * `EXT_clip_control` sets depth to [0, 1] as WebGPU has it: only y is flipped. Without it,
+     * naga maps z to [-1, 1] too (the same depth values, less precision far away).
+     */
+    clipControl: boolean;
+}
+export interface Naga {
+    /** naga's release: part of every translation's cache key. */
+    readonly version: string;
+    translate(wgsl: string, entry: string, stage: GlslStage, options: TranslateOptions): GlslTranslation;
+}
+/** Loads naga once. Rejects with `gpu-webgl2/naga-load-failed` if the module can't be fetched. */
+export declare function loadNaga(): Promise<Naga>;

package/dist/naga.js

@@ -0,0 +1,99 @@
+import { ShardError } from "@aethervtt/shard-core";
+const ADJUST_COORDINATE_SPACE = 1;
+const Z_REMAP = "gl_Position.yz = vec2(-gl_Position.y, gl_Position.z * 2.0 - gl_Position.w);";
+const Y_FLIP = "gl_Position.y = -gl_Position.y;";
+let loading;
+function loadNaga() {
+  loading ??= (async () => {
+    const module = await compileNaga();
+    return nagaFrom(module);
+  })();
+  loading.catch(() => {
+    loading = void 0;
+  });
+  return loading;
+}
+async function compileNaga() {
+  const url = new URL("../wasm/shard_naga.wasm", import.meta.url);
+  try {
+    if (url.protocol === "file:") {
+      const { readFile } = await import("node:fs/promises");
+      const data = await readFile(url);
+      return await WebAssembly.compile(
+        new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
+      );
+    }
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    return await WebAssembly.compileStreaming(response);
+  } catch (cause) {
+    throw new ShardError(
+      "gpu-webgl2/naga-load-failed",
+      "Couldn't load naga, the shader translator",
+      {
+        cause,
+        path: url.href,
+        hint: "packages/gpu-webgl2/wasm must be served with the app (rebuild with `pnpm build:wasm`)."
+      }
+    );
+  }
+}
+function nagaFrom(module) {
+  let exports = instantiate(module);
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  const read = () => decoder.decode(
+    new Uint8Array(exports.memory.buffer, exports.result_ptr(), exports.result_len())
+  );
+  exports.version();
+  const version = read();
+  return {
+    version,
+    translate(wgsl, entry, stage, options) {
+      const src = encoder.encode(wgsl);
+      const name = encoder.encode(entry);
+      let status;
+      let json;
+      try {
+        const srcPtr = exports.alloc(src.length);
+        const namePtr = exports.alloc(name.length);
+        new Uint8Array(exports.memory.buffer, srcPtr, src.length).set(src);
+        new Uint8Array(exports.memory.buffer, namePtr, name.length).set(name);
+        status = exports.translate(
+          srcPtr,
+          src.length,
+          namePtr,
+          name.length,
+          stage === "vertex" ? 0 : 1,
+          ADJUST_COORDINATE_SPACE
+        );
+        json = read();
+        exports.dealloc(srcPtr, src.length);
+        exports.dealloc(namePtr, name.length);
+      } catch (cause) {
+        exports = instantiate(module);
+        throw new ShardError("gpu-webgl2/naga-crashed", `naga crashed translating ${entry}`, {
+          cause,
+          hint: "Report the shader: naga should return an error, not crash."
+        });
+      }
+      const result = JSON.parse(json);
+      if (status !== 0 || "error" in result) {
+        throw new ShardError(
+          "gpu-webgl2/translate",
+          `WGSL \u2192 GLSL failed for ${entry}: ${result.error}`
+        );
+      }
+      if (options.clipControl && stage === "vertex") {
+        result.glsl = result.glsl.replaceAll(Z_REMAP, Y_FLIP);
+      }
+      return result;
+    }
+  };
+}
+function instantiate(module) {
+  return new WebAssembly.Instance(module, {}).exports;
+}
+export {
+  loadNaga
+};