@mui/x-charts-premium 9.7.0 → 9.9.0

package/utils/webgl/instancedAttribute.d.ts

@@ -0,0 +1,28 @@
+import type { GrowableBuffer } from "./utils.js";
+export interface InstancedAttribute {
+  buffer: GrowableBuffer;
+  location: number;
+  size: number;
+  glType: GLenum;
+  normalized: boolean;
+}
+/**
+ * Creates a per-instance vertex attribute backed by a fresh grow-only GPU buffer.
+ *
+ * The caller MUST have the owning VAO bound when calling this — the
+ * vertexAttribPointer + vertexAttribDivisor calls register the binding into
+ * that VAO and the program then references it on each draw.
+ */
+export declare function createInstancedAttribute(gl: WebGL2RenderingContext, program: WebGLProgram, name: string, size: number, glType?: GLenum, normalized?: boolean): InstancedAttribute;
+/**
+ * Wires up a per-instance vertex attribute that reads from an existing GrowableBuffer.
+ * Use this when the same buffer must back the same-named attribute in multiple
+ * VAOs (e.g. two shader-program variants over the same data).
+ *
+ * The caller MUST have the owning VAO bound when calling this.
+ *
+ * If the attribute is missing from the program (typo, or optimized out by the
+ * compiler), `getAttribLocation` returns -1. We skip the GL setup in that case to
+ * avoid `INVALID_VALUE` errors from `enableVertexAttribArray(-1)` and warn in dev.
+ */
+export declare function bindInstancedAttribute(gl: WebGL2RenderingContext, program: WebGLProgram, name: string, buffer: GrowableBuffer, size: number, glType?: GLenum, normalized?: boolean): InstancedAttribute;

package/utils/webgl/instancedAttribute.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bindInstancedAttribute = bindInstancedAttribute;
+exports.createInstancedAttribute = createInstancedAttribute;
+var _utils = require("./utils");
+/**
+ * Creates a per-instance vertex attribute backed by a fresh grow-only GPU buffer.
+ *
+ * The caller MUST have the owning VAO bound when calling this — the
+ * vertexAttribPointer + vertexAttribDivisor calls register the binding into
+ * that VAO and the program then references it on each draw.
+ */
+function createInstancedAttribute(gl, program, name, size, glType = gl.FLOAT, normalized = false) {
+  const buffer = (0, _utils.createGrowableBuffer)(gl);
+  return bindInstancedAttribute(gl, program, name, buffer, size, glType, normalized);
+}
+
+/**
+ * Wires up a per-instance vertex attribute that reads from an existing GrowableBuffer.
+ * Use this when the same buffer must back the same-named attribute in multiple
+ * VAOs (e.g. two shader-program variants over the same data).
+ *
+ * The caller MUST have the owning VAO bound when calling this.
+ *
+ * If the attribute is missing from the program (typo, or optimized out by the
+ * compiler), `getAttribLocation` returns -1. We skip the GL setup in that case to
+ * avoid `INVALID_VALUE` errors from `enableVertexAttribArray(-1)` and warn in dev.
+ */
+function bindInstancedAttribute(gl, program, name, buffer, size, glType = gl.FLOAT, normalized = false) {
+  const location = gl.getAttribLocation(program, name);
+  if (location === -1) {
+    if (process.env.NODE_ENV !== 'production') {
+      console.warn(`WebGL attribute "${name}" not found in shader program (misspelled or optimized out).`);
+    }
+    return {
+      buffer,
+      location,
+      size,
+      glType,
+      normalized
+    };
+  }
+  gl.bindBuffer(gl.ARRAY_BUFFER, buffer.buffer);
+  gl.enableVertexAttribArray(location);
+  gl.vertexAttribPointer(location, size, glType, normalized, 0, 0);
+  gl.vertexAttribDivisor(location, 1);
+  return {
+    buffer,
+    location,
+    size,
+    glType,
+    normalized
+  };
+}

package/utils/webgl/instancedAttribute.mjs

@@ -0,0 +1,50 @@
+import { createGrowableBuffer } from "./utils.mjs";
+/**
+ * Creates a per-instance vertex attribute backed by a fresh grow-only GPU buffer.
+ *
+ * The caller MUST have the owning VAO bound when calling this — the
+ * vertexAttribPointer + vertexAttribDivisor calls register the binding into
+ * that VAO and the program then references it on each draw.
+ */
+export function createInstancedAttribute(gl, program, name, size, glType = gl.FLOAT, normalized = false) {
+  const buffer = createGrowableBuffer(gl);
+  return bindInstancedAttribute(gl, program, name, buffer, size, glType, normalized);
+}
+
+/**
+ * Wires up a per-instance vertex attribute that reads from an existing GrowableBuffer.
+ * Use this when the same buffer must back the same-named attribute in multiple
+ * VAOs (e.g. two shader-program variants over the same data).
+ *
+ * The caller MUST have the owning VAO bound when calling this.
+ *
+ * If the attribute is missing from the program (typo, or optimized out by the
+ * compiler), `getAttribLocation` returns -1. We skip the GL setup in that case to
+ * avoid `INVALID_VALUE` errors from `enableVertexAttribArray(-1)` and warn in dev.
+ */
+export function bindInstancedAttribute(gl, program, name, buffer, size, glType = gl.FLOAT, normalized = false) {
+  const location = gl.getAttribLocation(program, name);
+  if (location === -1) {
+    if (process.env.NODE_ENV !== 'production') {
+      console.warn(`WebGL attribute "${name}" not found in shader program (misspelled or optimized out).`);
+    }
+    return {
+      buffer,
+      location,
+      size,
+      glType,
+      normalized
+    };
+  }
+  gl.bindBuffer(gl.ARRAY_BUFFER, buffer.buffer);
+  gl.enableVertexAttribArray(location);
+  gl.vertexAttribPointer(location, size, glType, normalized, 0, 0);
+  gl.vertexAttribDivisor(location, 1);
+  return {
+    buffer,
+    location,
+    size,
+    glType,
+    normalized
+  };
+}

package/utils/webgl/utils.d.mts

@@ -1,7 +1,6 @@
 export declare function compileShader(gl: WebGL2RenderingContext, shaderSource: string, shaderType: WebGL2RenderingContext['FRAGMENT_SHADER'] | WebGL2RenderingContext['VERTEX_SHADER']): WebGLShader;
 export declare function uploadQuadBuffer(gl: WebGL2RenderingContext): WebGLBuffer;
 export declare function bindQuadBuffer(gl: WebGL2RenderingContext, program: WebGLProgram, quadBuffer: WebGLBuffer): void;
-export declare function attachShader(gl: WebGL2RenderingContext, program: WebGLProgram, shaderSource: string, shaderType: WebGL2RenderingContext['FRAGMENT_SHADER'] | WebGL2RenderingContext['VERTEX_SHADER']): WebGLShader;
 export type GrowableBuffer = {
   buffer: WebGLBuffer;
   capacity: number;
@@ -18,4 +17,24 @@ export declare function uploadGrowableBuffer(gl: WebGL2RenderingContext, target:
 /**
  * Logs WebGL errors to the console in development mode.
  */
-export declare function logWebGLErrors(gl: WebGL2RenderingContext): void;
+export declare function logWebGLErrors(gl: WebGL2RenderingContext): void;
+/** Enables the standard non-premultiplied src-alpha blending used by all premium WebGL renderers. */
+export declare function setupStandardBlending(gl: WebGL2RenderingContext): void;
+/**
+ * Returns `existing` when it's large enough to hold `length` elements, otherwise
+ * allocates a fresh typed array via `Ctor`. Lets consumers keep one ref per
+ * pool and short-circuit growth checks inline.
+ */
+export declare function ensurePool<T extends {
+  length: number;
+}>(existing: T | null | undefined, length: number, Ctor: new (length: number) => T): T;
+export interface LinkedProgram {
+  program: WebGLProgram;
+  /** The vertex + fragment shaders that were attached. Hold them so dispose() can delete them. */
+  shaders: WebGLShader[];
+}
+/**
+ * Compiles vertex + fragment shaders, attaches them, links the program, and returns
+ * both the program and its shaders. Logs link/compile diagnostics in dev when linking fails.
+ */
+export declare function linkProgram(gl: WebGL2RenderingContext, vertexShaderSource: string, fragmentShaderSource: string): LinkedProgram;

package/utils/webgl/utils.d.ts

@@ -1,7 +1,6 @@
 export declare function compileShader(gl: WebGL2RenderingContext, shaderSource: string, shaderType: WebGL2RenderingContext['FRAGMENT_SHADER'] | WebGL2RenderingContext['VERTEX_SHADER']): WebGLShader;
 export declare function uploadQuadBuffer(gl: WebGL2RenderingContext): WebGLBuffer;
 export declare function bindQuadBuffer(gl: WebGL2RenderingContext, program: WebGLProgram, quadBuffer: WebGLBuffer): void;
-export declare function attachShader(gl: WebGL2RenderingContext, program: WebGLProgram, shaderSource: string, shaderType: WebGL2RenderingContext['FRAGMENT_SHADER'] | WebGL2RenderingContext['VERTEX_SHADER']): WebGLShader;
 export type GrowableBuffer = {
   buffer: WebGLBuffer;
   capacity: number;
@@ -18,4 +17,24 @@ export declare function uploadGrowableBuffer(gl: WebGL2RenderingContext, target:
 /**
  * Logs WebGL errors to the console in development mode.
  */
-export declare function logWebGLErrors(gl: WebGL2RenderingContext): void;
+export declare function logWebGLErrors(gl: WebGL2RenderingContext): void;
+/** Enables the standard non-premultiplied src-alpha blending used by all premium WebGL renderers. */
+export declare function setupStandardBlending(gl: WebGL2RenderingContext): void;
+/**
+ * Returns `existing` when it's large enough to hold `length` elements, otherwise
+ * allocates a fresh typed array via `Ctor`. Lets consumers keep one ref per
+ * pool and short-circuit growth checks inline.
+ */
+export declare function ensurePool<T extends {
+  length: number;
+}>(existing: T | null | undefined, length: number, Ctor: new (length: number) => T): T;
+export interface LinkedProgram {
+  program: WebGLProgram;
+  /** The vertex + fragment shaders that were attached. Hold them so dispose() can delete them. */
+  shaders: WebGLShader[];
+}
+/**
+ * Compiles vertex + fragment shaders, attaches them, links the program, and returns
+ * both the program and its shaders. Logs link/compile diagnostics in dev when linking fails.
+ */
+export declare function linkProgram(gl: WebGL2RenderingContext, vertexShaderSource: string, fragmentShaderSource: string): LinkedProgram;

package/utils/webgl/utils.js

@@ -3,11 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.attachShader = attachShader;
 exports.bindQuadBuffer = bindQuadBuffer;
 exports.compileShader = compileShader;
 exports.createGrowableBuffer = createGrowableBuffer;
+exports.ensurePool = ensurePool;
+exports.linkProgram = linkProgram;
 exports.logWebGLErrors = logWebGLErrors;
+exports.setupStandardBlending = setupStandardBlending;
 exports.uploadGrowableBuffer = uploadGrowableBuffer;
 exports.uploadQuadBuffer = uploadQuadBuffer;
 function compileShader(gl, shaderSource, shaderType) {
@@ -29,13 +31,6 @@ function bindQuadBuffer(gl, program, quadBuffer) {
   gl.enableVertexAttribArray(aPosition);
   gl.vertexAttribPointer(aPosition, 2, gl.FLOAT, false, 0, 0);
 }
-function attachShader(gl, program, shaderSource, shaderType) {
-  const shader = gl.createShader(shaderType);
-  gl.shaderSource(shader, shaderSource);
-  gl.compileShader(shader);
-  gl.attachShader(program, shader);
-  return shader;
-}
 function createGrowableBuffer(gl) {
   return {
     buffer: gl.createBuffer(),
@@ -77,4 +72,45 @@ function logWebGLErrors(gl) {
       error = gl.getError();
     }
   }
+}
+
+/** Enables the standard non-premultiplied src-alpha blending used by all premium WebGL renderers. */
+function setupStandardBlending(gl) {
+  gl.enable(gl.BLEND);
+  gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+}
+
+/**
+ * Returns `existing` when it's large enough to hold `length` elements, otherwise
+ * allocates a fresh typed array via `Ctor`. Lets consumers keep one ref per
+ * pool and short-circuit growth checks inline.
+ */
+function ensurePool(existing, length, Ctor) {
+  if (existing != null && existing.length >= length) {
+    return existing;
+  }
+  return new Ctor(length);
+}
+/**
+ * Compiles vertex + fragment shaders, attaches them, links the program, and returns
+ * both the program and its shaders. Logs link/compile diagnostics in dev when linking fails.
+ */
+function linkProgram(gl, vertexShaderSource, fragmentShaderSource) {
+  const program = gl.createProgram();
+  const vertexShader = compileShader(gl, vertexShaderSource, gl.VERTEX_SHADER);
+  const fragmentShader = compileShader(gl, fragmentShaderSource, gl.FRAGMENT_SHADER);
+  gl.attachShader(program, vertexShader);
+  gl.attachShader(program, fragmentShader);
+  gl.linkProgram(program);
+  if (process.env.NODE_ENV !== 'production' && !gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    // WebGL best-practices: consult compile/link status only in dev mode
+    // https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/WebGL_best_practices#dont_check_shader_compile_status_unless_linking_fails
+    console.error(`Program linking failed: ${gl.getProgramInfoLog(program)}`);
+    console.error(`Vertex shader info-log: ${gl.getShaderInfoLog(vertexShader)}`);
+    console.error(`Fragment shader info-log: ${gl.getShaderInfoLog(fragmentShader)}`);
+  }
+  return {
+    program,
+    shaders: [vertexShader, fragmentShader]
+  };
 }

package/utils/webgl/utils.mjs

@@ -17,13 +17,6 @@ export function bindQuadBuffer(gl, program, quadBuffer) {
   gl.enableVertexAttribArray(aPosition);
   gl.vertexAttribPointer(aPosition, 2, gl.FLOAT, false, 0, 0);
 }
-export function attachShader(gl, program, shaderSource, shaderType) {
-  const shader = gl.createShader(shaderType);
-  gl.shaderSource(shader, shaderSource);
-  gl.compileShader(shader);
-  gl.attachShader(program, shader);
-  return shader;
-}
 export function createGrowableBuffer(gl) {
   return {
     buffer: gl.createBuffer(),
@@ -65,4 +58,45 @@ export function logWebGLErrors(gl) {
       error = gl.getError();
     }
   }
+}
+
+/** Enables the standard non-premultiplied src-alpha blending used by all premium WebGL renderers. */
+export function setupStandardBlending(gl) {
+  gl.enable(gl.BLEND);
+  gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+}
+
+/**
+ * Returns `existing` when it's large enough to hold `length` elements, otherwise
+ * allocates a fresh typed array via `Ctor`. Lets consumers keep one ref per
+ * pool and short-circuit growth checks inline.
+ */
+export function ensurePool(existing, length, Ctor) {
+  if (existing != null && existing.length >= length) {
+    return existing;
+  }
+  return new Ctor(length);
+}
+/**
+ * Compiles vertex + fragment shaders, attaches them, links the program, and returns
+ * both the program and its shaders. Logs link/compile diagnostics in dev when linking fails.
+ */
+export function linkProgram(gl, vertexShaderSource, fragmentShaderSource) {
+  const program = gl.createProgram();
+  const vertexShader = compileShader(gl, vertexShaderSource, gl.VERTEX_SHADER);
+  const fragmentShader = compileShader(gl, fragmentShaderSource, gl.FRAGMENT_SHADER);
+  gl.attachShader(program, vertexShader);
+  gl.attachShader(program, fragmentShader);
+  gl.linkProgram(program);
+  if (process.env.NODE_ENV !== 'production' && !gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    // WebGL best-practices: consult compile/link status only in dev mode
+    // https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/WebGL_best_practices#dont_check_shader_compile_status_unless_linking_fails
+    console.error(`Program linking failed: ${gl.getProgramInfoLog(program)}`);
+    console.error(`Vertex shader info-log: ${gl.getShaderInfoLog(vertexShader)}`);
+    console.error(`Fragment shader info-log: ${gl.getShaderInfoLog(fragmentShader)}`);
+  }
+  return {
+    program,
+    shaders: [vertexShader, fragmentShader]
+  };
 }