@kitware/vtk.js 34.2.0 → 34.3.1

package/Common/Core/Math/index.js

@@ -2256,4 +2256,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { min as $, degreesFromRadians as A, ldexp as B, xyz2rgb as C, areEquals as D, clampValue as E, arrayRange as F, getMajorAxisIndex as G, createUninitializedBounds as H, identity as I, multiplyMatrix as J, floor as K, isInf as L, rgb2hsv as M, rgb2lab as N, lab2rgb as O, round as P, normalize2D as Q, nearestPowerOfTwo as R, multiply3x3_vect3 as S, getSparseOrthogonalMatrix as T, areBoundsInitialized as U, isPowerOfTwo as V, angleBetweenVectors as W, signedAngleBetweenVectors as X, createArray as Y, Pi as Z, ceil as _, areMatricesEqual as a, floatRGB2HexCode as a$, max as a0, arrayMin as a1, arrayMax as a2, ceilLog2 as a3, factorial as a4, binomial as a5, beginCombination as a6, nextCombination as a7, randomSeed as a8, getSeed as a9, multiplyQuaternion as aA, orthogonalize3x3 as aB, diagonalize3x3 as aC, singularValueDecomposition3x3 as aD, luFactorLinearSystem as aE, luSolveLinearSystem as aF, invertMatrix as aG, estimateMatrixCondition as aH, solveHomogeneousLeastSquares as aI, solveLeastSquares as aJ, hex2float as aK, lab2xyz as aL, xyz2lab as aM, rgb2xyz as aN, computeBoundsFromPoints as aO, clampAndNormalizeValue as aP, getScalarTypeFittingRange as aQ, getAdjustedScalarRange as aR, extentIsWithinOtherExtent as aS, boundsIsWithinOtherBounds as aT, pointIsWithinBounds as aU, solve3PointCircle as aV, inf as aW, negInf as aX, isFinite as aY, isNaN as aZ, floatToHex2 as a_, gaussian as aa, multiplyScalar2D as ab, multiplyAccumulate2D as ac, outer as ad, projectVector as ae, dot2D as af, projectVector2D as ag, gaussianAmplitude as ah, gaussianWeight as ai, outer2D as aj, norm2D as ak, rowsToMat4 as al, columnsToMat4 as am, columnsToMat3 as an, LUFactor3x3 as ao, LUSolve3x3 as ap, linearSolve3x3 as aq, multiply3x3_mat3 as ar, transpose3x3 as as, invert3x3 as at, identity3x3 as au, isIdentity as av, isIdentity3x3 as aw, quaternionToMatrix3x3 as ax, roundNumber as ay, matrix3x3ToQuaternion as az, roundVector as b, float2CssRGBA as b0, clampVector as c, dot as d, distance2BetweenPoints as e, vtkMath as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, subtract as s, jacobi as t, uninitializeBounds as u, vtkMath$1 as v, multiplyScalar as w, random as x, determinant3x3 as y, rowsToMat3 as z };
+export { ceil as $, degreesFromRadians as A, ldexp as B, xyz2rgb as C, areEquals as D, clampValue as E, arrayRange as F, getMajorAxisIndex as G, createUninitializedBounds as H, identity as I, multiplyMatrix as J, floor as K, isInf as L, rgb2hsv as M, rgb2lab as N, lab2rgb as O, round as P, normalize2D as Q, nearestPowerOfTwo as R, multiply3x3_vect3 as S, getSparseOrthogonalMatrix as T, areBoundsInitialized as U, floatRGB2HexCode as V, isPowerOfTwo as W, angleBetweenVectors as X, signedAngleBetweenVectors as Y, createArray as Z, Pi as _, areMatricesEqual as a, floatToHex2 as a$, min as a0, max as a1, arrayMin as a2, arrayMax as a3, ceilLog2 as a4, factorial as a5, binomial as a6, beginCombination as a7, nextCombination as a8, randomSeed as a9, matrix3x3ToQuaternion as aA, multiplyQuaternion as aB, orthogonalize3x3 as aC, diagonalize3x3 as aD, singularValueDecomposition3x3 as aE, luFactorLinearSystem as aF, luSolveLinearSystem as aG, invertMatrix as aH, estimateMatrixCondition as aI, solveHomogeneousLeastSquares as aJ, solveLeastSquares as aK, hex2float as aL, lab2xyz as aM, xyz2lab as aN, rgb2xyz as aO, computeBoundsFromPoints as aP, clampAndNormalizeValue as aQ, getScalarTypeFittingRange as aR, getAdjustedScalarRange as aS, extentIsWithinOtherExtent as aT, boundsIsWithinOtherBounds as aU, pointIsWithinBounds as aV, solve3PointCircle as aW, inf as aX, negInf as aY, isFinite as aZ, isNaN as a_, getSeed as aa, gaussian as ab, multiplyScalar2D as ac, multiplyAccumulate2D as ad, outer as ae, projectVector as af, dot2D as ag, projectVector2D as ah, gaussianAmplitude as ai, gaussianWeight as aj, outer2D as ak, norm2D as al, rowsToMat4 as am, columnsToMat4 as an, columnsToMat3 as ao, LUFactor3x3 as ap, LUSolve3x3 as aq, linearSolve3x3 as ar, multiply3x3_mat3 as as, transpose3x3 as at, invert3x3 as au, identity3x3 as av, isIdentity as aw, isIdentity3x3 as ax, quaternionToMatrix3x3 as ay, roundNumber as az, roundVector as b, float2CssRGBA as b0, clampVector as c, dot as d, distance2BetweenPoints as e, vtkMath as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, subtract as s, jacobi as t, uninitializeBounds as u, vtkMath$1 as v, multiplyScalar as w, random as x, determinant3x3 as y, rowsToMat3 as z };

package/Common/Core/Math.js

@@ -1,4 +1,4 @@
 import 'seedrandom';
 import '../../macros2.js';
 import './Math/Constants.js';
-export { ao as LUFactor3x3, ap as LUSolve3x3, Z as Pi, k as add, W as angleBetweenVectors, U as areBoundsInitialized, D as areEquals, a as areMatricesEqual, a2 as arrayMax, a1 as arrayMin, F as arrayRange, a6 as beginCombination, a5 as binomial, aT as boundsIsWithinOtherBounds, _ as ceil, a3 as ceilLog2, aP as clampAndNormalizeValue, E as clampValue, c as clampVector, an as columnsToMat3, am as columnsToMat4, aO as computeBoundsFromPoints, Y as createArray, H as createUninitializedBounds, j as cross, f as default, A as degreesFromRadians, o as determinant2x2, y as determinant3x3, aC as diagonalize3x3, e as distance2BetweenPoints, d as dot, af as dot2D, aH as estimateMatrixCondition, aS as extentIsWithinOtherExtent, a4 as factorial, b0 as float2CssRGBA, a$ as floatRGB2HexCode, a_ as floatToHex2, K as floor, aa as gaussian, ah as gaussianAmplitude, ai as gaussianWeight, aR as getAdjustedScalarRange, G as getMajorAxisIndex, aQ as getScalarTypeFittingRange, a9 as getSeed, T as getSparseOrthogonalMatrix, aK as hex2float, h as hsv2rgb, I as identity, au as identity3x3, aW as inf, at as invert3x3, aG as invertMatrix, aY as isFinite, av as isIdentity, aw as isIdentity3x3, L as isInf, aZ as isNaN, i as isNan, V as isPowerOfTwo, t as jacobi, p as jacobiN, O as lab2rgb, aL as lab2xyz, B as ldexp, aq as linearSolve3x3, aE as luFactorLinearSystem, aF as luSolveLinearSystem, az as matrix3x3ToQuaternion, a0 as max, $ as min, ar as multiply3x3_mat3, S as multiply3x3_vect3, m as multiplyAccumulate, ac as multiplyAccumulate2D, J as multiplyMatrix, aA as multiplyQuaternion, w as multiplyScalar, ab as multiplyScalar2D, R as nearestPowerOfTwo, aX as negInf, a7 as nextCombination, n as norm, ak as norm2D, l as normalize, Q as normalize2D, aB as orthogonalize3x3, ad as outer, aj as outer2D, q as perpendiculars, aU as pointIsWithinBounds, ae as projectVector, ag as projectVector2D, ax as quaternionToMatrix3x3, r as radiansFromDegrees, x as random, a8 as randomSeed, M as rgb2hsv, N as rgb2lab, aN as rgb2xyz, P as round, ay as roundNumber, b as roundVector, z as rowsToMat3, al as rowsToMat4, X as signedAngleBetweenVectors, aD as singularValueDecomposition3x3, aV as solve3PointCircle, aI as solveHomogeneousLeastSquares, aJ as solveLeastSquares, g as solveLinearSystem, s as subtract, as as transpose3x3, u as uninitializeBounds, aM as xyz2lab, C as xyz2rgb } from './Math/index.js';
+export { ap as LUFactor3x3, aq as LUSolve3x3, _ as Pi, k as add, X as angleBetweenVectors, U as areBoundsInitialized, D as areEquals, a as areMatricesEqual, a3 as arrayMax, a2 as arrayMin, F as arrayRange, a7 as beginCombination, a6 as binomial, aU as boundsIsWithinOtherBounds, $ as ceil, a4 as ceilLog2, aQ as clampAndNormalizeValue, E as clampValue, c as clampVector, ao as columnsToMat3, an as columnsToMat4, aP as computeBoundsFromPoints, Z as createArray, H as createUninitializedBounds, j as cross, f as default, A as degreesFromRadians, o as determinant2x2, y as determinant3x3, aD as diagonalize3x3, e as distance2BetweenPoints, d as dot, ag as dot2D, aI as estimateMatrixCondition, aT as extentIsWithinOtherExtent, a5 as factorial, b0 as float2CssRGBA, V as floatRGB2HexCode, a$ as floatToHex2, K as floor, ab as gaussian, ai as gaussianAmplitude, aj as gaussianWeight, aS as getAdjustedScalarRange, G as getMajorAxisIndex, aR as getScalarTypeFittingRange, aa as getSeed, T as getSparseOrthogonalMatrix, aL as hex2float, h as hsv2rgb, I as identity, av as identity3x3, aX as inf, au as invert3x3, aH as invertMatrix, aZ as isFinite, aw as isIdentity, ax as isIdentity3x3, L as isInf, a_ as isNaN, i as isNan, W as isPowerOfTwo, t as jacobi, p as jacobiN, O as lab2rgb, aM as lab2xyz, B as ldexp, ar as linearSolve3x3, aF as luFactorLinearSystem, aG as luSolveLinearSystem, aA as matrix3x3ToQuaternion, a1 as max, a0 as min, as as multiply3x3_mat3, S as multiply3x3_vect3, m as multiplyAccumulate, ad as multiplyAccumulate2D, J as multiplyMatrix, aB as multiplyQuaternion, w as multiplyScalar, ac as multiplyScalar2D, R as nearestPowerOfTwo, aY as negInf, a8 as nextCombination, n as norm, al as norm2D, l as normalize, Q as normalize2D, aC as orthogonalize3x3, ae as outer, ak as outer2D, q as perpendiculars, aV as pointIsWithinBounds, af as projectVector, ah as projectVector2D, ay as quaternionToMatrix3x3, r as radiansFromDegrees, x as random, a9 as randomSeed, M as rgb2hsv, N as rgb2lab, aO as rgb2xyz, P as round, az as roundNumber, b as roundVector, z as rowsToMat3, am as rowsToMat4, Y as signedAngleBetweenVectors, aE as singularValueDecomposition3x3, aW as solve3PointCircle, aJ as solveHomogeneousLeastSquares, aK as solveLeastSquares, g as solveLinearSystem, s as subtract, at as transpose3x3, u as uninitializeBounds, aN as xyz2lab, C as xyz2rgb } from './Math/index.js';

package/Rendering/Core/TextActor.d.ts

@@ -0,0 +1,64 @@
+import vtkActor2D, { IActor2DInitialValues } from './Actor2D';
+import vtkTextProperty, { ITextPropertyInitialValues } from './TextProperty';
+
+export interface ITextActorInitialValues extends IActor2DInitialValues {
+  property?: vtkTextProperty;
+}
+
+export interface vtkTextActor extends vtkActor2D {
+  /**
+   * Get the property object that controls this actors properties.
+   * @returns {vtkTextProperty} The vtkTextProperty instance.
+   */
+  getProperty(): vtkTextProperty;
+
+  /**
+   * Create a new property suitable for use with this type of TextActor.
+   * @param {ITextPropertyInitialValues} [initialValues] (default: {})
+   * @return {vtkTextProperty} A new vtkTextProperty instance.
+   */
+  makeProperty(initialValues?: ITextPropertyInitialValues): vtkTextProperty;
+
+  /**
+   * Set the text to be displayed by the actor.
+   * @param input The text to be displayed by the actor.
+   */
+  setInput(input: string): boolean;
+
+  /**
+   * Set the property object that controls this actors properties.
+   * @param {vtkTextProperty} property The vtkTextProperty instance.
+   */
+  setProperty(property: vtkTextProperty): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkActor characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {ITextActorInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: ITextActorInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkTextActor
+ *
+ * @param {ITextActorInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: ITextActorInitialValues
+): vtkTextActor;
+
+/**
+ * vtkTextActor can be used to place text annotation into a window.
+ */
+export declare const vtkTextActor: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkTextActor;

package/Rendering/Core/TextActor.js

@@ -0,0 +1,134 @@
+import { m as macro } from '../../macros2.js';
+import vtkPlaneSource from '../../Filters/Sources/PlaneSource.js';
+import vtkTexture from './Texture.js';
+import vtkActor2D from './Actor2D.js';
+import vtkMapper2D from './Mapper2D.js';
+import vtkTextProperty from './TextProperty.js';
+import ImageHelper from '../../Common/Core/ImageHelper.js';
+import { V as floatRGB2HexCode } from '../../Common/Core/Math/index.js';
+
+// ----------------------------------------------------------------------------
+// vtkTextActor methods
+// ----------------------------------------------------------------------------
+function vtkTextActor(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkTextActor');
+  publicAPI.makeProperty = vtkTextProperty.newInstance;
+  const texture = vtkTexture.newInstance({
+    resizable: true
+  });
+  const canvas = new OffscreenCanvas(1, 1);
+  const mapper = vtkMapper2D.newInstance();
+  const plane = vtkPlaneSource.newInstance({
+    xResolution: 1,
+    yResolution: 1
+  });
+  function createImageData(text) {
+    const fontSizeScale = publicAPI.getProperty().getFontSizeScale();
+    const fontStyle = publicAPI.getProperty().getFontStyle();
+    const fontFamily = publicAPI.getProperty().getFontFamily();
+    const fontColor = publicAPI.getProperty().getFontColor();
+    const shadowColor = publicAPI.getProperty().getShadowColor();
+    const shadowOffset = publicAPI.getProperty().getShadowOffset();
+    const shadowBlur = publicAPI.getProperty().getShadowBlur();
+    const resolution = publicAPI.getProperty().getResolution();
+    const backgroundColor = publicAPI.getProperty().getBackgroundColor();
+    const dpr = Math.max(window.devicePixelRatio || 1, 1);
+    const ctx = canvas.getContext('2d');
+
+    // Set the text properties to measure
+    const textSize = fontSizeScale(resolution) * dpr;
+    ctx.font = `${fontStyle} ${textSize}px "${fontFamily}"`;
+    ctx.textBaseline = 'middle';
+    ctx.textAlign = 'center';
+
+    // Measure the text
+    const metrics = ctx.measureText(text);
+    const textWidth = metrics.width / dpr;
+    const {
+      actualBoundingBoxLeft,
+      actualBoundingBoxRight,
+      actualBoundingBoxAscent,
+      actualBoundingBoxDescent
+    } = metrics;
+    const hAdjustment = (actualBoundingBoxLeft - actualBoundingBoxRight) / 2;
+    const vAdjustment = (actualBoundingBoxAscent - actualBoundingBoxDescent) / 2;
+    const textHeight = textSize / dpr - vAdjustment;
+
+    // Update canvas size to fit text and ensure it is at least 1x1 pixel
+    const width = Math.max(Math.round(textWidth * dpr), 1);
+    const height = Math.max(Math.round(textHeight * dpr), 1);
+    canvas.width = width;
+    canvas.height = height;
+
+    // Vertical flip
+    ctx.translate(0, height);
+    ctx.scale(1, -1);
+
+    // Clear the canvas
+    ctx.clearRect(0, 0, width, height);
+    if (backgroundColor) {
+      ctx.fillStyle = floatRGB2HexCode(backgroundColor);
+      ctx.fillRect(0, 0, width, height);
+    }
+
+    // Reset context after resize and prepare for rendering
+    ctx.imageSmoothingEnabled = true;
+    ctx.imageSmoothingQuality = 'high';
+    ctx.font = `${fontStyle} ${textSize}px "${fontFamily}"`;
+    ctx.fillStyle = floatRGB2HexCode(fontColor);
+    ctx.textBaseline = 'middle';
+    ctx.textAlign = 'center';
+
+    // Set shadow
+    if (shadowColor) {
+      ctx.shadowColor = floatRGB2HexCode(shadowColor);
+      ctx.shadowOffsetX = shadowOffset[0];
+      ctx.shadowOffsetY = shadowOffset[1];
+      ctx.shadowBlur = shadowBlur;
+    }
+
+    // Draw the text
+    ctx.fillText(text, width / 2 + hAdjustment, height / 2 + vAdjustment);
+
+    // Update plane dimensions to match text size
+    plane.set({
+      point1: [width, 0, 0],
+      point2: [0, height, 0]
+    });
+    return ImageHelper.canvasToImageData(canvas);
+  }
+  mapper.setInputConnection(plane.getOutputPort());
+  publicAPI.setMapper(mapper);
+  publicAPI.addTexture(texture);
+  model._onInputChanged = (_publicAPI, _model, value) => {
+    const image = createImageData(value);
+    texture.setInputData(image, 0);
+  };
+}
+
+// Default property values
+const DEFAULT_VALUES = {
+  mapper: null,
+  property: null
+};
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Inheritance
+  vtkActor2D.extend(publicAPI, model, initialValues);
+
+  // Build VTK API
+  macro.setGet(publicAPI, model, ['input']);
+
+  // Object methods
+  vtkTextActor(publicAPI, model);
+}
+const newInstance = macro.newInstance(extend, 'vtkTextActor');
+var vtkTextActor$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkTextActor$1 as default, extend, newInstance };

package/Rendering/Core/TextProperty.d.ts

@@ -0,0 +1,206 @@
+import { RGBColor } from './../../types';
+import vtkProperty2D, { IProperty2DInitialValues } from './Property2D';
+
+export interface ITextPropertyInitialValues extends IProperty2DInitialValues {
+  backgroundColor?: RGBColor;
+  fillStyle?: string;
+  fontColor?: RGBColor;
+  fontFamily?: string;
+  fontSizeScale?: (resolution: number) => number;
+  fontStyle?: string;
+  resolution?: number;
+  shadowBlur?: number;
+  shadowColor?: RGBColor;
+  shadowOffset?: [number, number];
+}
+
+export interface vtkTextProperty extends vtkProperty2D {
+  /**
+   * Get the background color.
+   */
+  getBackgroundColor(): RGBColor;
+
+  /**
+   * Get the background color by reference.
+   */
+  getBackgroundColorByReference(): RGBColor;
+
+  /**
+   * Get the fill style.
+   */
+  getFillStyle(): string;
+
+  /**
+   * Get the font color.
+   */
+  getFontColor(): RGBColor;
+
+  /**
+   * Get the font color by reference.
+   */
+  getFontColorByReference(): RGBColor;
+
+  /**
+   * Get the font family.
+   */
+  getFontFamily(): string;
+
+  /**
+   * Get the font size scale.
+   */
+  getFontSizeScale(): (resolution: number) => number;
+
+  /**
+   * Get the font style.
+   */
+  getFontStyle(): string;
+
+  /**
+   * Get the resolution.
+   */
+  getResolution(): number;
+
+  /**
+   * Get the shadow blur radius.
+   */
+  getShadowBlur(): number;
+
+  /**
+   * Get the shadow color.
+   */
+  getShadowColor(): RGBColor;
+
+  /**
+   * Get the shadow color by reference.
+   */
+  getShadowColorByReference(): RGBColor;
+
+  /**
+   * Get the shadow offset.
+   */
+  getShadowOffset(): [number, number];
+
+  /**
+   * Get the shadow offset by reference.
+   */
+  getShadowOffsetByReference(): [number, number];
+
+  /**
+   * Set the background color.
+   * @param {RGBColor} backgroundColor The background color to set.
+   */
+  setBackgroundColor(backgroundColor: RGBColor): boolean;
+
+  /**
+   * Set the fill style.
+   * @param {string} fillStyle The fill style to set.
+   */
+  setFillStyle(fillStyle: string): boolean;
+
+  /**
+   * Set the font color from RGB values.
+   * @param {number} r Red component (0-255)
+   * @param {number} g Green component (0-255)
+   * @param {number} b Blue component (0-255)
+   */
+  setFontColor(r: number, g: number, b: number): boolean;
+
+  /**
+   * Set the font color.
+   * @param {RGBColor} fontColor The font color to set.
+   */
+  setFontColorFrom(fontColor: RGBColor): boolean;
+
+  /**
+   * Set the font family.
+   * @param {string} fontFamily The font family to set.
+   */
+  setFontFamily(fontFamily: string): boolean;
+
+  /**
+   * Set the font size scale.
+   * Scales the font size based on the given resolution.
+   * Dividing by 1.8 ensures the font size is proportionate and not too large.
+   * The value 1.8 is a chosen scaling factor for visual balance.
+   * @param {number} resolution The resolution to set.
+   */
+  setFontSizeScale(resolution: number): number;
+
+  /**
+   * Set the font style.
+   * @param {string} fontStyle The font style to set.
+   */
+  setFontStyle(fontStyle: string): boolean;
+
+  /**
+   * Set the resolution.
+   * @param {number} resolution The resolution to set.
+   */
+  setResolution(resolution: number): boolean;
+
+  /**
+   * Set the shadow blur radius.
+   * @param {number} shadowBlur The shadow blur radius to set.
+   */
+  setShadowBlur(shadowBlur: number): boolean;
+
+  /**
+   * Set the shadow color from RGB values.
+   * @param {number} r Red component (0-255)
+   * @param {number} g Green component (0-255)
+   * @param {number} b Blue component (0-255)
+   */
+  setShadowColor(r: number, g: number, b: number): boolean;
+
+  /**
+   * Set the shadow color.
+   * @param {RGBColor} shadowColor The shadow color to set.
+   */
+  setShadowColorFrom(shadowColor: RGBColor): boolean;
+
+  /**
+   * Set the shadow offset from x and y values.
+   * @param {number} x Horizontal offset
+   * @param {number} y Vertical offset
+   */
+  setShadowOffset(x: number, y: number): boolean;
+
+  /**
+   * Set the shadow offset.
+   * @param {Array} shadowOffset The shadow offset to set, as an array of [x, y].
+   */
+  setShadowOffsetFrom(shadowOffset: [number, number]): boolean;
+}
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkProperty characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {ITextPropertyInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: ITextPropertyInitialValues
+): void;
+
+/**
+ * Method use to create a new instance of vtkTextProperty.
+ * @param {ITextPropertyInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: ITextPropertyInitialValues
+): vtkTextProperty;
+
+/**
+ * vtkTextProperty is an object that represents text properties. The primary
+ * properties that can be set are color, opacity, font size, font family
+ * horizontal and vertical justification, bold/italic/shadow styles.
+ */
+export declare const vtkTextProperty: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
+export default vtkTextProperty;

package/Rendering/Core/TextProperty.js

@@ -0,0 +1,61 @@
+import { m as macro } from '../../macros2.js';
+import vtkProperty2D from './Property2D.js';
+
+// ----------------------------------------------------------------------------
+// vtkTextProperty methods
+// ----------------------------------------------------------------------------
+
+function vtkTextProperty(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkTextProperty');
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  fontFamily: 'Arial',
+  fontColor: [0, 0, 0],
+  fontStyle: 'normal',
+  // backgroundColor: [1, 1, 1],
+  // Scales the font size based on the given resolution.
+  // Dividing by 1.8 ensures the font size is proportionate and not too large.
+  // The value 1.8 is a chosen scaling factor for visual balance.
+  fontSizeScale: resolution => resolution / 1.8,
+  resolution: 200
+  // shadowColor: [1, 1, 0],
+  // shadowOffset: [1, -1],
+  // shadowBlur: 0,
+};
+
+// ----------------------------------------------------------------------------
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Inheritance
+  vtkProperty2D.extend(publicAPI, model, initialValues);
+
+  // Build VTK API
+
+  macro.setGet(publicAPI, model, ['fontFamily', 'fontStyle', 'fillStyle', 'fontSizeScale', 'resolution', 'shadowBlur']);
+  macro.setGetArray(publicAPI, model, ['shadowOffset'], 2);
+  macro.setGetArray(publicAPI, model, ['backgroundColor', 'fontColor', 'shadowColor'], 3);
+
+  // Object methods
+  vtkTextProperty(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkTextProperty');
+
+// ----------------------------------------------------------------------------
+
+var vtkTextProperty$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkTextProperty$1 as default, extend, newInstance };

package/Rendering/Core.js

@@ -38,6 +38,8 @@ import vtkSkybox from './Core/Skybox.js';
 import vtkSphereMapper from './Core/SphereMapper.js';
 import vtkStickMapper from './Core/StickMapper.js';
 import vtkTexture from './Core/Texture.js';
+import vtkTextActor from './Core/TextActor.js';
+import vtkTextProperty from './Core/TextProperty.js';
 import vtkVector from './Core/VectorText.js';
 import vtkViewport from './Core/Viewport.js';
 import vtkVolume from './Core/Volume.js';
@@ -88,6 +90,8 @@ var Core = {
   vtkSphereMapper,
   vtkStickMapper,
   vtkTexture,
+  vtkTextActor,
+  vtkTextProperty,
   vtkVector,
   vtkViewport,
   vtkVolume,

package/Rendering/OpenGL/Texture.js

@@ -3,7 +3,7 @@ import Constants from './Texture/Constants.js';
 import HalfFloat from '../../Common/Core/HalfFloat.js';
 import { n as newInstance$1, o as obj, s as set, e as setGet, g as get, i as moveToProtected, a as newTypedArray, c as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { V as isPowerOfTwo, R as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { W as isPowerOfTwo, R as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 import supportsNorm16LinearCached from './Texture/supportsNorm16Linear.js';

package/Rendering/WebGPU/CellArrayMapper.js

@@ -71,6 +71,30 @@ struct PBRData {
   specular: vec3<f32>,
 }
 
+struct Material {
+  ior: f32,
+  roughness: f32,
+  metallic: f32,
+  base: vec3<f32>,
+};
+
+struct DirectionalLight {
+  direction: vec3<f32>,
+  color: vec3<f32>,
+};
+
+struct PointLight {
+  position: vec3<f32>,
+  color: vec3<f32>,
+};
+
+struct SpotLight {
+  position: vec3<f32>,
+  direction: vec3<f32>,
+  cones: vec2<f32>,
+  color: vec3<f32>,
+};
+
 const pi: f32 = 3.14159265359;
 
 // Dot product with the max already in it
@@ -175,53 +199,51 @@ fn cookTorrance(D: f32, F: f32, G: f32, N: vec3<f32>, V: vec3<f32>, L: vec3<f32>
 }
 
 // Different lighting calculations for different light sources
-fn calcDirectionalLight(N: vec3<f32>, V: vec3<f32>, ior: f32, roughness: f32, metallic: f32, direction: vec3<f32>, color: vec3<f32>, base: vec3<f32>) -> PBRData {
-  var L: vec3<f32> = normalize(direction); // Light Vector
+fn calcDirectionalLight(N: vec3<f32>, V: vec3<f32>, mat: Material, light: DirectionalLight) -> PBRData {
+  var L: vec3<f32> = normalize(light.direction); // Light Vector
   var H: vec3<f32> = normalize(L + V); // Halfway Vector
 
-  var alpha = roughness*roughness;
-  var k: f32 = alpha*alpha / 2;
+  var alpha = mat.roughness * mat.roughness;
+  var k: f32 = alpha * alpha / 2.0;
 
   var D: f32 = trGGX(N, H, alpha); // Distribution
   // var F: f32 = schlickFresnelIOR(V, N, ior, k); // Fresnel
   var G: f32 = smithSurfaceRoughness(N, V, L, k); // Geometry
 
   var brdf: f32 = cookTorrance(D, 1.0, G, N, V, L); // Fresnel term is replaced with 1 because it is added later
-  var incoming: vec3<f32> = color;
+  var incoming: vec3<f32> = light.color;
   var angle: f32 = mdot(L, N);
   angle = pow(angle, 1.5);
 
-  var specular: vec3<f32> = brdf*incoming*angle;
+  var specular: vec3<f32> = brdf * incoming * angle;
   // Oren-Nayar gives a clay-like effect when fully rough which some people may not want, so it might be better to give a separate
   // control property for the diffuse vs specular roughness
-  var diffuse: vec3<f32> = incoming*fujiiOrenNayar(base, roughness, N, L, V);
+  var diffuse: vec3<f32> = incoming * fujiiOrenNayar(mat.base, mat.roughness, N, L, V);
   // Stores the specular and diffuse separately to allow for finer post processing
   var out = PBRData(diffuse, specular);
 
   return out; // Returns angle along with color of light so the final color can be multiplied by angle as well (creates black areas)
 }
 
-// TODO: find some way to reduce the number of arguments going in here
-fn calcPointLight(N: vec3<f32>, V: vec3<f32>, fragPos: vec3<f32>, ior: f32, roughness: f32, metallic: f32, position: vec3<f32>, color: vec3<f32>, base: vec3<f32>) -> PBRData {
-  var L: vec3<f32> = normalize(position - fragPos); // Light Vector
-  var H: vec3<f32> = normalize(L + V); // Halfway Vector
-  var dist = distance(position, fragPos);
+fn calcPointLight(N: vec3<f32>, V: vec3<f32>, fragPos: vec3<f32>, mat: Material, light: PointLight) -> PBRData {
+  var L: vec3<f32> = normalize(light.position - fragPos);
+  var H: vec3<f32> = normalize(L + V);
+  var dist = distance(light.position, fragPos);
 
-  var alpha = roughness*roughness;
-  var k: f32 = alpha*alpha / 2.0; // could also be pow(alpha + 1.0, 2) / 8
+  var alpha = mat.roughness * mat.roughness;
+  var k: f32 = alpha * alpha / 2.0;
 
   var D: f32 = trGGX(N, H, alpha); // Distribution
-  // var F: f32 = schlickFresnelIOR(V, N, ior, k); // Fresnel
+  var F: f32 = schlickFresnelIOR(V, N, mat.ior, k); // Fresnel
   var G: f32 = smithSurfaceRoughness(N, V, L, k); // Geometry
 
   var brdf: f32 = cookTorrance(D, 1.0, G, N, V, L);
-  var incoming: vec3<f32> = color * (1.0 / (dist*dist));
+  var incoming: vec3<f32> = light.color * (1.0 / (dist * dist));
   var angle: f32 = mdot(L, N);
-  angle = pow(angle, 1.5); // Smoothing factor makes it less accurate, but reduces ugly "seams" bewteen light sources
-
-  var specular: vec3<f32> = brdf*incoming*angle;
-  var diffuse: vec3<f32> = incoming*fujiiOrenNayar(base, roughness, N, L, V);
+  angle = pow(angle, 1.5); // Smoothing factor makes it less accurate, but reduces ugly "seams" between light sources
 
+  var specular: vec3<f32> = brdf * incoming * angle;
+  var diffuse: vec3<f32> = incoming * fujiiOrenNayar(mat.base, mat.roughness, N, L, V);
   // Stores the specular and diffuse separately to allow for finer post processing
   // Could also be done (propably more properly) with a struct
   var out = PBRData(diffuse, specular);
@@ -230,13 +252,13 @@ fn calcPointLight(N: vec3<f32>, V: vec3<f32>, fragPos: vec3<f32>, ior: f32, roug
 }
 
 // For a reason unknown to me, spheres dont seem to behave propperly with head-on spot lights
-fn calcSpotLight(N: vec3<f32>, V: vec3<f32>, fragPos: vec3<f32>, ior: f32, roughness: f32, metallic: f32, position: vec3<f32>, direction: vec3<f32>, cones: vec2<f32>, color: vec3<f32>, base: vec3<f32>) -> PBRData {
-  var L: vec3<f32> = normalize(position - fragPos);
+fn calcSpotLight(N: vec3<f32>, V: vec3<f32>, fragPos: vec3<f32>, mat: Material, light: SpotLight) -> PBRData {
+  var L: vec3<f32> = normalize(light.position - fragPos);
   var H: vec3<f32> = normalize(L + V); // Halfway Vector
-  var dist = distance(position, fragPos);
+  var dist = distance(light.position, fragPos);
 
-  var alpha = roughness*roughness;
-  var k: f32 = alpha*alpha / 2.0; // could also be pow(alpha + 1.0, 2) / 8
+  var alpha = mat.roughness * mat.roughness;
+  var k: f32 = alpha * alpha / 2.0; // could also be pow(alpha + 1.0, 2) / 8
 
   var D: f32 = trGGX(N, H, alpha); // Distribution
   // var F: f32 = schlickFresnelIOR(V, N, ior, k); // Fresnel
@@ -244,20 +266,19 @@ fn calcSpotLight(N: vec3<f32>, V: vec3<f32>, fragPos: vec3<f32>, ior: f32, rough
 
   var brdf: f32 = cookTorrance(D, 1.0, G, N, V, L);
 
-  // Cones.x is the inner phi and cones.y is the outer phi
-  var theta: f32 = mdot(normalize(direction), L);
-  var epsilon: f32 = cones.x - cones.y;
-  var intensity: f32 = (theta - cones.y) / epsilon;
+  var theta: f32 = mdot(normalize(light.direction), L);
+  var epsilon: f32 = light.cones.x - light.cones.y;
+  var intensity: f32 = (theta - light.cones.y) / epsilon;
   intensity = clamp(intensity, 0.0, 1.0);
-  intensity /= dist*dist;
+  intensity /= dist * dist;
 
-  var incoming: vec3<f32> = color * intensity;
+  var incoming: vec3<f32> = light.color * intensity;
 
   var angle: f32 = mdot(L, N);
-  angle = pow(angle, 1.5); // Smoothing factor makes it less accurate, but reduces ugly "seams" bewteen light sources
+  angle = pow(angle, 1.5); // Smoothing factor makes it less accurate, but reduces ugly "seams" between light sources
 
-  var specular: vec3<f32> = brdf*incoming*angle;
-  var diffuse: vec3<f32> = incoming*fujiiOrenNayar(base, roughness, N, L, V);
+  var specular: vec3<f32> = brdf * incoming * angle;
+  var diffuse: vec3<f32> = incoming * fujiiOrenNayar(mat.base, mat.roughness, N, L, V);
 
   // Stores the specular and diffuse separately to allow for finer post processing
   // Could also be done (propably more properly) with a struct
@@ -310,6 +331,7 @@ fn main(
   var ambientColor: vec4<f32> = mapperUBO.AmbientColor;
   var diffuseColor: vec4<f32> = mapperUBO.DiffuseColor;
   var opacity: f32 = mapperUBO.Opacity;
+  var ior: f32 = mapperUBO.BaseIOR;
 
   // This should be declared somewhere else
   var _diffuseMap: vec4<f32> = vec4<f32>(1.0);
@@ -331,6 +353,8 @@ fn main(
 
   //VTK::Select::Impl
 
+  // Use texture alpha for transparency
+  computedColor.a = mapperUBO.Opacity * _diffuseMap.a;
   if (computedColor.a == 0.0) { discard; };
 
   //VTK::Position::Impl
@@ -525,31 +549,29 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
     if (code.includes('var normal:') && model.useRendererMatrix && !isEdges(hash) && !model.is2D && !hash.includes('sel')) {
       const lightingCode = [
       // Vectors needed for light calculations
-      '  var fragPos: vec3<f32> = vec3<f32>(input.vertexVC.xyz);', '  var V: vec3<f32> = mix(normalize(-fragPos), vec3<f32>(0, 0, 1), f32(rendererUBO.cameraParallel)); // View Vector',
+      '  let fragPos = vec3<f32>(input.vertexVC.xyz);', '  let V = mix(normalize(-fragPos), vec3<f32>(0, 0, 1), f32(rendererUBO.cameraParallel)); // View Vector',
       // Values needed for light calculations
-      '  var baseColor: vec3<f32> = _diffuseMap.rgb * diffuseColor.rgb;', '  var roughness: f32 = max(0.000001, mapperUBO.Roughness * _roughnessMap.r);',
+      '  let baseColor = _diffuseMap.rgb * diffuseColor.rgb;', '  let roughness = max(0.000001, mapperUBO.Roughness * _roughnessMap.r);',
       // Need to have a different way of sampling greyscale values aside from .r
-      '  var metallic: f32 = mapperUBO.Metallic * _metallicMap.r;', '  var alpha: f32 = roughness*roughness;', '  var ior: f32 = mapperUBO.BaseIOR;', '  var k: f32 = alpha*alpha / 2;',
+      '  let metallic = mapperUBO.Metallic * _metallicMap.r;', '  let alpha = roughness * roughness;', '  let k = alpha * alpha / 2.0;',
       // Split diffuse and specular components
-      '  var diffuse: vec3<f32> = vec3<f32>(0.);', '  var specular: vec3<f32> = vec3<f32>(0.);', '  var emission: vec3<f32> = _emissionMap.rgb * mapperUBO.Emission;',
+      '  var diffuse = vec3<f32>(0.);', '  var specular = vec3<f32>(0.);', '  let emission = _emissionMap.rgb * mapperUBO.Emission;', '', '  // Material struct', '  let mat = Material(ior, roughness, metallic, baseColor);', '',
       // Summing diffuse and specular components of directional lights
-      '  {', '    var i: i32 = 0;', '    loop {', '      if !(i < rendererUBO.LightCount) { break; }', '      switch (i32(rendererLightSSBO.values[i].LightData.x)) {', '         // Point Light', '         case 0 {', '           var color: vec3<f32> = rendererLightSSBO.values[i].LightColor.rgb * rendererLightSSBO.values[i].LightColor.w;', '           var pos: vec3<f32> = (rendererLightSSBO.values[i].LightPos).xyz;', '           var calculated: PBRData = calcPointLight(normal, V, fragPos, ior, roughness, metallic, pos, color, baseColor);', '           diffuse += max(vec3<f32>(0), calculated.diffuse);', '           specular += max(vec3<f32>(0), calculated.specular);', '          }', '         // Directional light', '         case 1 {', '           var dir: vec3<f32> = (rendererUBO.WCVCNormals * vec4<f32>(normalize(rendererLightSSBO.values[i].LightDir.xyz), 0.)).xyz;', '           dir = normalize(dir);', '           var color: vec3<f32> = rendererLightSSBO.values[i].LightColor.rgb * rendererLightSSBO.values[i].LightColor.w;', '           var calculated: PBRData = calcDirectionalLight(normal, V, ior, roughness, metallic, dir, color, baseColor); // diffuseColor.rgb needs to be fixed with a more dynamic diffuse color', '           diffuse += max(vec3<f32>(0), calculated.diffuse);', '           specular += max(vec3<f32>(0), calculated.specular);', '         }', '         // Spot Light', '         case 2 {', '           var color: vec3<f32> = rendererLightSSBO.values[i].LightColor.rgb * rendererLightSSBO.values[i].LightColor.w;', '           var pos: vec3<f32> = (rendererLightSSBO.values[i].LightPos).xyz;', '           var dir: vec3<f32> = (rendererUBO.WCVCNormals * vec4<f32>(normalize(rendererLightSSBO.values[i].LightDir.xyz), 0.)).xyz;', '           dir = normalize(dir);', '           var cones: vec2<f32> = vec2<f32>(rendererLightSSBO.values[i].LightData.y, rendererLightSSBO.values[i].LightData.z);', '           var calculated: PBRData = calcSpotLight(normal, V, fragPos, ior, roughness, metallic, pos, dir, cones, color, baseColor);', '           diffuse += max(vec3<f32>(0), calculated.diffuse);', '           specular += max(vec3<f32>(0), calculated.specular);', '         }', '         default { continue; }', '       }', '      continuing { i++; }', '    }', '  }',
+      '  {', '    var i = 0;', '    loop {', '      if (!(i < rendererUBO.LightCount)) { break; }', '      switch (i32(rendererLightSSBO.values[i].LightData.x)) {', '         // Point Light', '         case 0 {', '           let color = rendererLightSSBO.values[i].LightColor.rgb * rendererLightSSBO.values[i].LightColor.w;', '           let pos = (rendererLightSSBO.values[i].LightPos).xyz;', '           let pointLight = PointLight(pos, color);', '           let result = calcPointLight(normal, V, fragPos, mat, pointLight);', '           diffuse += max(vec3<f32>(0), result.diffuse);', '           specular += max(vec3<f32>(0), result.specular);', '          }', '         // Directional light', '         case 1 {', '           let dir = normalize((rendererUBO.WCVCNormals * vec4<f32>(normalize(rendererLightSSBO.values[i].LightDir.xyz), 0.)).xyz);', '           let color = rendererLightSSBO.values[i].LightColor.rgb * rendererLightSSBO.values[i].LightColor.w;', '           let dirLight = DirectionalLight(dir, color);', '           let result = calcDirectionalLight(normal, V, mat, dirLight); // diffuseColor.rgb needs to be fixed with a more dynamic diffuse color', '           diffuse += max(vec3<f32>(0), result.diffuse);', '           specular += max(vec3<f32>(0), result.specular);', '         }', '         // Spot Light', '         case 2 {', '           let color = rendererLightSSBO.values[i].LightColor.rgb * rendererLightSSBO.values[i].LightColor.w;', '           let pos = (rendererLightSSBO.values[i].LightPos).xyz;', '           let dir = normalize((rendererUBO.WCVCNormals * vec4<f32>(normalize(rendererLightSSBO.values[i].LightDir.xyz), 0.)).xyz);', '           let cones = vec2<f32>(rendererLightSSBO.values[i].LightData.y, rendererLightSSBO.values[i].LightData.z);', '           let spotLight = SpotLight(pos, dir, cones, color);', '           let result = calcSpotLight(normal, V, fragPos, mat, spotLight);', '           diffuse += max(vec3<f32>(0), result.diffuse);', '           specular += max(vec3<f32>(0), result.specular);', '         }', '         default { continue; }', '       }', '      continuing { i++; }', '    }', '  }',
       // Final variables for combining specular and diffuse
-      '  var fresnel: f32 = schlickFresnelIOR(V, normal, ior, k); // Fresnel', '  fresnel = min(1.0, fresnel);', '  // This could be controlled with its own variable (that isnt base color) for better artistic control', '  var fresnelMetallic: vec3<f32> = schlickFresnelRGB(V, normal, baseColor); // Fresnel for metal, takes color into account', '  var kS: vec3<f32> = mix(vec3<f32>(fresnel), fresnelMetallic, metallic);', '  kS = min(vec3<f32>(1.0), kS);', '  var kD: vec3<f32> = (1.0 - kS) * (1.0 - metallic);', '  var PBR: vec3<f32> = mapperUBO.DiffuseIntensity*kD*diffuse + kS*specular;', '  PBR += emission;', '  computedColor = vec4<f32>(PBR, mapperUBO.Opacity);'];
+      '  let fresnel = min(1.0, schlickFresnelIOR(V, normal, ior, k)); // Fresnel', '  // This could be controlled with its own variable (that isnt base color) for better artistic control', '  let fresnelMetallic = schlickFresnelRGB(V, normal, baseColor); // Fresnel for metal, takes color into account', '  let kS = min(vec3<f32>(1.0), mix(vec3<f32>(fresnel), fresnelMetallic, metallic));', '  let kD = (1.0 - kS) * (1.0 - metallic);', '  let PBR = mapperUBO.DiffuseIntensity * kD * diffuse + kS * specular;', '  computedColor = vec4<f32>(PBR + emission, mapperUBO.Opacity);'];
       if (renderer.getEnvironmentTexture()?.getImageLoaded()) {
-        lightingCode.push('  // To get diffuse IBL, the texture is sampled with normals in worldspace', '  var diffuseIBLCoords: vec3<f32> = (transpose(rendererUBO.WCVCNormals) * vec4<f32>(normal, 1.)).xyz;', '  var diffuseCoords: vec2<f32> = vecToRectCoord(diffuseIBLCoords);', '  // To get specular IBL, the texture is sampled as the worldspace reflection between the normal and view vectors', '  // Reflections are first calculated in viewspace, then converted to worldspace to sample the environment', '  var VreflN: vec3<f32> = normalize(reflect(-V, normal));', '  var reflectionIBLCoords = (transpose(rendererUBO.WCVCNormals) * vec4<f32>(VreflN, 1.)).xyz;', '  var specularCoords: vec2<f32> = vecToRectCoord(reflectionIBLCoords);', '  var diffuseIBL = textureSampleLevel(EnvironmentTexture, EnvironmentTextureSampler, diffuseCoords, rendererUBO.MaxEnvironmentMipLevel);',
+        lightingCode.push('  // To get diffuse IBL, the texture is sampled with normals in worldspace', '  let diffuseIBLCoords = (transpose(rendererUBO.WCVCNormals) * vec4<f32>(normal, 1.)).xyz;', '  let diffuseCoords = vecToRectCoord(diffuseIBLCoords);', '  // To get specular IBL, the texture is sampled as the worldspace reflection between the normal and view vectors', '  // Reflections are first calculated in viewspace, then converted to worldspace to sample the environment', '  let VreflN = normalize(reflect(-V, normal));', '  let reflectionIBLCoords = (transpose(rendererUBO.WCVCNormals) * vec4<f32>(VreflN, 1.)).xyz;', '  let specularCoords = vecToRectCoord(reflectionIBLCoords);', '  let diffuseIBL = textureSampleLevel(EnvironmentTexture, EnvironmentTextureSampler, diffuseCoords, rendererUBO.MaxEnvironmentMipLevel);',
         // Level multiplier should be set by UBO
-        '  var level = roughness * rendererUBO.MaxEnvironmentMipLevel;', '  var specularIBL = textureSampleLevel(EnvironmentTexture, EnvironmentTextureSampler, specularCoords, level);',
+        '  let level = roughness * rendererUBO.MaxEnvironmentMipLevel;', '  let specularIBL = textureSampleLevel(EnvironmentTexture, EnvironmentTextureSampler, specularCoords, level);',
         // Manual mip smoothing since not all formats support smooth level sampling
-        '  var specularIBLContribution: vec3<f32> = specularIBL.rgb*rendererUBO.BackgroundSpecularStrength;', '  computedColor += vec4<f32>(specularIBLContribution*kS, 0);', '  var diffuseIBLContribution: vec3<f32> = diffuseIBL.rgb*rendererUBO.BackgroundDiffuseStrength;', '  diffuseIBLContribution *= baseColor * _ambientOcclusionMap.rgb;',
-        // Multipy by baseColor may be changed
-        '  computedColor += vec4<f32>(diffuseIBLContribution*kD, 0);');
+        '  let specularIBLContribution = specularIBL.rgb * rendererUBO.BackgroundSpecularStrength;', '  computedColor += vec4<f32>(specularIBLContribution * kS, 0);', '  let diffuseIBLContribution = diffuseIBL.rgb * rendererUBO.BackgroundDiffuseStrength;', '  computedColor += vec4<f32>(diffuseIBLContribution * baseColor * _ambientOcclusionMap.rgb * kD, 0);');
       }
       code = vtkWebGPUShaderCache.substitute(code, '//VTK::Light::Impl', lightingCode).result;
       fDesc.setCode(code);
       // If theres no normals, just set the specular color to be flat
     } else {
-      code = vtkWebGPUShaderCache.substitute(code, '//VTK::Light::Impl', ['  var diffuse: vec3<f32> = diffuseColor.rgb;', '  var specular: vec3<f32> = mapperUBO.SpecularColor.rgb * mapperUBO.SpecularColor.a;', '  computedColor = vec4<f32>(diffuse * _diffuseMap.rgb, mapperUBO.Opacity);']).result;
+      code = vtkWebGPUShaderCache.substitute(code, '//VTK::Light::Impl', ['  let diffuse = diffuseColor.rgb;', '  let specular = mapperUBO.SpecularColor.rgb * mapperUBO.SpecularColor.a;', '  computedColor = vec4<f32>(diffuse * _diffuseMap.rgb, mapperUBO.Opacity);']).result;
       fDesc.setCode(code);
     }
   };

package/Widgets/Widgets3D/AngleWidget.js

@@ -3,7 +3,7 @@ import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkPolyLineRepresentation from '../Representations/PolyLineRepresentation.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
-import { s as subtract, W as angleBetweenVectors } from '../../Common/Core/Math/index.js';
+import { s as subtract, X as angleBetweenVectors } from '../../Common/Core/Math/index.js';
 import widgetBehavior from './AngleWidget/behavior.js';
 import generateState from './AngleWidget/state.js';
 import { ViewTypes } from '../Core/WidgetManager/Constants.js';

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../../macros2.js';
 import vtkBoundingBox from '../../../Common/DataModel/BoundingBox.js';
 import vtkLine from '../../../Common/DataModel/Line.js';
-import { k as add, l as normalize, s as subtract, d as dot, j as cross, m as multiplyAccumulate, w as multiplyScalar, X as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
+import { k as add, l as normalize, s as subtract, d as dot, j as cross, m as multiplyAccumulate, w as multiplyScalar, Y as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
 import { getLineNames, getOtherLineName, updateState, boundPointOnPlane, getLinePlaneName, getLineInPlaneName, rotateVector } from './helpers.js';
 import { InteractionMethodsName, ScrollingMethods, planeNameToViewType } from './Constants.js';
 

package/Widgets/Widgets3D/ResliceCursorWidget/helpers.js

@@ -2,7 +2,7 @@ import vtkBoundingBox, { STATIC } from '../../../Common/DataModel/BoundingBox.js
 import vtkCubeSource from '../../../Filters/Sources/CubeSource.js';
 import vtkCutter from '../../../Filters/Core/Cutter.js';
 import vtkPlane from '../../../Common/DataModel/Plane.js';
-import { s as subtract, l as normalize, j as cross, w as multiplyScalar, m as multiplyAccumulate, X as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
+import { s as subtract, l as normalize, j as cross, w as multiplyScalar, m as multiplyAccumulate, Y as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../../Common/Core/MatrixBuilder.js';
 import { viewTypeToPlaneName, planeNameToViewType, planeNames } from './Constants.js';
 

package/index.d.ts

@@ -205,6 +205,8 @@
 /// <reference path="./Rendering/Core/Skybox.d.ts" />
 /// <reference path="./Rendering/Core/SphereMapper.d.ts" />
 /// <reference path="./Rendering/Core/StickMapper.d.ts" />
+/// <reference path="./Rendering/Core/TextActor.d.ts" />
+/// <reference path="./Rendering/Core/TextProperty.d.ts" />
 /// <reference path="./Rendering/Core/Texture.d.ts" />
 /// <reference path="./Rendering/Core/VectorText.d.ts" />
 /// <reference path="./Rendering/Core/Viewport.d.ts" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "34.2.0",
+  "version": "34.3.1",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",