@kitware/vtk.js 25.1.3 → 25.2.0

package/Rendering/Core/Light.d.ts

@@ -5,7 +5,7 @@ import { RGBColor, Vector3 } from './../../types';
 export enum LIGHT_TYPES {
 	'HeadLight',
 	'CameraLight',
-	'SceneLight'
+	'SceneLight',
 }
 
 export interface ILightInitialValues {
@@ -17,6 +17,7 @@ export interface ILightInitialValues {
 	positional?: boolean;
 	exponent?: number;
 	coneAngle?: number;
+	coneFalloff?: number;
 	attenuationValues?: number[];
 	lightType?: LIGHT_TYPES;
 	shadowAttenuation?: number;
@@ -54,6 +55,15 @@ export interface vtkLight extends vtkObject {
 	 */
 	getConeAngle(): number;
 
+	/**
+	 * Get the lighting falloff angle of a positional light in degrees.
+	 * This is the angle that sets how much the cone will be extended to
+	 * smooth the border. A value of 0 indicates that the spot light will
+	 * have a completely sharp edge (this does not mean completely sharp
+	 * lighting, just that the border will be sharp).
+	 */
+	getConeFalloff(): number;
+
 	/**
 	 * Set the position and focal point of a light based on elevation and azimuth.
 	 * The light is moved so it is shining from the given angle. Angles are
@@ -174,6 +184,16 @@ export interface vtkLight extends vtkObject {
 	 */
 	setConeAngle(coneAngle: number): boolean;
 
+	/**
+	 * Set the lighting falloff angle of a positional light in degrees.
+	 * This is the angle that sets how much the cone will be extended to
+	 * smooth the border. A value of 0 indicates that the spot light will
+	 * have a completely sharp edge (this does not mean completely sharp
+	 * lighting, just that the border will be sharp).
+	 * @param {Number} coneFalloff The cone falloff angle.
+	 */
+	setConeFalloff(coneFalloff: number): boolean;
+
 	/**
 	 * Set the position and focal point of a light based on elevation and
 	 * azimuth. The light is moved so it is shining from the given angle. Angles
@@ -184,6 +204,20 @@ export interface vtkLight extends vtkObject {
 	 */
 	setDirectionAngle(elevation: number, azimuth: number): boolean;
 
+	/**
+	 * Set the direction vector of the light from X, Y, and Z values
+	 * @param {Number} x The x coordinate.
+	 * @param {Number} y The y coordinate.
+	 * @param {Number} z The z coordinate.
+	 */
+	setDirection(x: number, y: number, z: number): boolean;
+
+	/**
+	 * Set the direction vector of the light from X, Y, and Z values
+	 * @param {Vector3} direction
+	 */
+	setDirection(direction: Vector3): boolean;
+
 	/**
 	 * Set the exponent of the cosine used in positional lighting.
 	 * @param {Number} exponent The exponent of the cosine.
@@ -299,7 +333,7 @@ export function extend(publicAPI: object, model: object, initialValues?: ILightI
 /**
  * Method use to create a new instance of vtkLight with the focal point at the origin and its position
  * set to [0, 0, 1]. The light is a SceneLight, its color is white, intensity=1, the light is turned on, 
- * positional lighting is off, coneAngle=30, AttenuationValues=[1, 0, 0], exponent=1 and the transformMatrix is null.
+ * positional lighting is off, coneAngle=30, coneFalloff=5, AttenuationValues=[1, 0, 0], exponent=1 and the transformMatrix is null.
  * @param {ILightInitialValues} [initialValues] for pre-setting some of its content
  */
 export function newInstance(initialValues?: ILightInitialValues): vtkLight;

package/Rendering/Core/Light.js

@@ -33,14 +33,19 @@ function vtkLight(publicAPI, model) {
 
   publicAPI.getDirection = function () {
     if (model.directionMTime < model.mtime) {
-      model.direction[0] = model.focalPoint[0] - model.position[0];
-      model.direction[1] = model.focalPoint[1] - model.position[1];
-      model.direction[2] = model.focalPoint[2] - model.position[2];
+      vec3.sub(model.direction, model.focalPoint, model.position);
       normalize(model.direction);
       model.directionMTime = model.mtime;
     }
 
     return model.direction;
+  }; // Sets the direction from a vec3 instead of a focal point
+
+
+  publicAPI.setDirection = function (directionVector) {
+    var newFocalPoint = new Float64Array(3);
+    vec3.sub(newFocalPoint, model.position, directionVector);
+    model.focalPoint = newFocalPoint;
   };
 
   publicAPI.setDirectionAngle = function (elevation, azimuth) {
@@ -89,6 +94,7 @@ var DEFAULT_VALUES = {
   positional: false,
   exponent: 1,
   coneAngle: 30,
+  coneFalloff: 5,
   attenuationValues: [1, 0, 0],
   transformMatrix: null,
   lightType: 'SceneLight',
@@ -102,7 +108,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
 
   macro.obj(publicAPI, model);
-  macro.setGet(publicAPI, model, ['intensity', 'switch', 'positional', 'exponent', 'coneAngle', 'transformMatrix', 'lightType', 'shadowAttenuation', 'attenuationValues']);
+  macro.setGet(publicAPI, model, ['intensity', 'switch', 'positional', 'exponent', 'coneAngle', 'coneFalloff', 'transformMatrix', 'lightType', 'shadowAttenuation', 'attenuationValues']);
   macro.setGetArray(publicAPI, model, ['color', 'position', 'focalPoint', 'attenuationValues'], 3); // Object methods
 
   vtkLight(publicAPI, model);

package/Rendering/Core/Property.d.ts

@@ -1,15 +1,27 @@
 import { vtkObject } from './../../interfaces';
 import { RGBColor } from './../../types';
 import { Interpolation, Representation, Shading } from './Property/Constants';
+import { vtkTexture } from './Texture';
 
 export interface IPropertyInitialValues {
 	color?: RGBColor;
 	ambientColor?: RGBColor;
 	diffuseColor?: RGBColor;
 	specularColor?: RGBColor;
+	diffuseTexture?: vtkTexture;
+	metallicTexture?: vtkTexture;
+	roughnessTexture?: vtkTexture;
+	normalTexture?: vtkTexture;
+	ambientOcclusionTexture?: vtkTexture;
+	emissionTexture?: vtkTexture;
 	edgeColor?: RGBColor;
 	ambient?: number;
 	diffuse?: number;
+	metallic?: number;
+	roughness?: number;
+	normalStrength?: number;
+	emission?: number;
+	baseIOR?: number;
 	specular?: number;
 	specularPower?: number;
 	opacity?: number;
@@ -161,6 +173,36 @@ export interface vtkProperty extends vtkObject {
 	 */
 	getSpecular(): number;
 
+	/**
+	 * Get the roughness coefficient.
+	 * @default 1
+	 */
+	getRoughness(): number;
+
+	/**
+	 * Get the metallic coefficient.
+	 * @default 0
+	 */
+	getMetallic(): number;
+
+	/**
+	 * Get the index of refraction.
+	 * @default 0
+	 */
+	getBaseIOR(): number;
+
+	/**
+	 * Get the strength of the normal map.
+	 * @default 1
+	 */
+	getNormalStrength(): number;
+
+	/**
+	 * Get the emission coefficient.
+	 * @default 0
+	 */
+	getEmission(): number;
+
 	/**
 	 * Get the specular surface color.
 	 * @return {RGBColor} Array of RGB color.
@@ -178,6 +220,36 @@ export interface vtkProperty extends vtkObject {
 	 */
 	getSpecularPower(): number;
 
+	/**
+	 * Get the diffuse texture.
+	 */
+	getDiffuseTexture(): vtkTexture;
+
+	/**
+	 * Get the metallic texture.
+	 */
+	getMetallicTexture(): vtkTexture;
+
+	/**
+	 * Get the roughness texture.
+	 */
+	getRoughnessTexture(): vtkTexture;
+
+	/**
+	 * Get the normal texture.
+	 */
+	getNormalTexture(): vtkTexture;
+
+	/**
+	 * Get the ambient occlusion texture.
+	 */
+	getAmbientOcclusionTexture(): vtkTexture;
+
+	/**
+	 * Get the emission texture.
+	 */
+	getEmissionTexture(): vtkTexture;
+
 	/**
 	 * Set the ambient lighting coefficient.
 	 * @param {Number} ambient The ambient lighting coefficient.
@@ -385,6 +457,18 @@ export interface vtkProperty extends vtkObject {
 	 */
 	setSpecular(specular: number): boolean;
 
+	/**
+	 * Set the normal map strength.
+	 * @param {Boolean} normal 
+	 */
+	setNormalStrength(normalStrength: number): boolean;
+
+	/**
+	 * Set the ambient occlusion map strength.
+	 * @param {Boolean} emission 
+	 */
+	setEmission(emission: number): boolean;
+
 	/**
 	 * Set the specular surface color.
 	 * @param {Number} r Defines the red component (between 0 and 1)
@@ -410,6 +494,42 @@ export interface vtkProperty extends vtkObject {
 	 * @param {Number} specularPower 
 	 */
 	setSpecularPower(specularPower: number): boolean;
+
+	/**
+	 * Set the diffuse texture.
+	 * @param {vtkTexture} diffuseTexture
+	 */
+	setDiffuseTexture(diffuseTexture: vtkTexture): boolean;
+
+	/**
+	 * Set the metallic texture.
+	 * @param {vtkTexture} metallicTexture
+	 */
+	setMetallicTexture(metallicTexture: vtkTexture): boolean;
+
+	/**
+	 * Set the roughness texture.
+	 * @param {vtkTexture} roughnessTexture
+	 */
+	setRoughnessTexture(roughnessTexture: vtkTexture): boolean;
+
+	/**
+	 * Set the normal texture.
+	 * @param {vtkTexture} normalTexture
+	 */
+	setNormalTexture(normalTexture: vtkTexture): boolean;
+
+	/**
+	 * Set the ambient occlusion texture.
+	 * @param {vtkTexture} ambientOcclusionTexture
+	 */
+	setAmbientOcclusionTexture(ambientOcclusionTexture: vtkTexture): boolean;
+
+	/**
+	 * Set the emission texture.
+	 * @param {vtkTexture} emissionTexture
+	 */
+	setEmissionTexture(emissionTexture: vtkTexture): boolean;
 }
 
 /**

package/Rendering/Core/Property.js

@@ -58,6 +58,17 @@ function vtkProperty(publicAPI, model) {
     return [].concat(model.color);
   };
 
+  publicAPI.setSpecularPower = function (specularPower) {
+    var roughness = 1 / Math.max(1.0, specularPower);
+
+    if (model.roughness !== roughness || model.specularPower !== specularPower) {
+      model.specularPower = specularPower; // Specular power still needs to be set as long as webgl is using it (otherwise testShaderReplacementsClear fails)
+
+      model.roughness = roughness;
+      publicAPI.modified();
+    }
+  };
+
   publicAPI.addShaderVariable = notImplemented('AddShaderVariable');
 
   publicAPI.setInterpolationToFlat = function () {
@@ -104,6 +115,11 @@ var DEFAULT_VALUES = {
   edgeColor: [0, 0, 0],
   ambient: 0,
   diffuse: 1,
+  metallic: 0,
+  roughness: 0.6,
+  normalStrength: 1,
+  emission: 1,
+  baseIOR: 1.45,
   specular: 0,
   specularPower: 1,
   opacity: 1,
@@ -124,7 +140,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
 
   macro.obj(publicAPI, model);
-  macro.setGet(publicAPI, model, ['lighting', 'interpolation', 'ambient', 'diffuse', 'specular', 'specularPower', 'opacity', 'edgeVisibility', 'lineWidth', 'pointSize', 'backfaceCulling', 'frontfaceCulling', 'representation']);
+  macro.setGet(publicAPI, model, ['lighting', 'interpolation', 'ambient', 'diffuse', 'metallic', 'roughness', 'normalStrength', 'emission', 'baseIOR', 'specular', 'specularPower', 'opacity', 'edgeVisibility', 'lineWidth', 'pointSize', 'backfaceCulling', 'frontfaceCulling', 'representation', 'diffuseTexture', 'metallicTexture', 'roughnessTexture', 'normalTexture', 'ambientOcclusionTexture', 'emissionTexture']);
   macro.setGetArray(publicAPI, model, ['ambientColor', 'specularColor', 'diffuseColor', 'edgeColor'], 3); // Object methods
 
   vtkProperty(publicAPI, model);

package/Rendering/Core/Texture.js

@@ -72,6 +72,37 @@ function vtkTexture(publicAPI, model) {
 
     publicAPI.modified();
   };
+
+  publicAPI.getDimensionality = function () {
+    var width = 0;
+    var height = 0;
+    var depth = 1;
+
+    if (publicAPI.getInputData()) {
+      var data = publicAPI.getInputData();
+      width = data.getDimensions()[0];
+      height = data.getDimensions()[1];
+      depth = data.getDimensions()[2];
+    }
+
+    if (model.jsImageData) {
+      width = model.jsImageData.width;
+      height = model.jsImageData.height;
+    }
+
+    if (model.canvas) {
+      width = model.canvas.width;
+      height = model.canvas.height;
+    }
+
+    if (model.image) {
+      width = model.image.width;
+      height = model.image.height;
+    }
+
+    var dimensionality = (width > 1) + (height > 1) + (depth > 1);
+    return dimensionality;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------

package/Rendering/WebGPU/CellArrayMapper.js

@@ -18,7 +18,7 @@ var ScalarMode = vtkMapper.ScalarMode;
 var CoordinateSystem = vtkProp.CoordinateSystem;
 var DisplayLocation = vtkProperty2D.DisplayLocation;
 var vtkWebGPUPolyDataVS = "\n//VTK::Renderer::Dec\n\n//VTK::Color::Dec\n\n//VTK::Normal::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::Select::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::IOStructs::Dec\n\n@vertex\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output : vertexOutput;\n\n  var vertex: vec4<f32> = vertexBC;\n\n  //VTK::Color::Impl\n\n  //VTK::Normal::Impl\n\n  //VTK::TCoord::Impl\n\n  //VTK::Select::Impl\n\n  //VTK::Position::Impl\n\n  return output;\n}\n";
-var vtkWebGPUPolyDataFS = "\n//VTK::Renderer::Dec\n\n//VTK::Color::Dec\n\n// optional surface normal declaration\n//VTK::Normal::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::Select::Dec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::IOStructs::Dec\n\n@fragment\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output : fragmentOutput;\n\n  var ambientColor: vec4<f32> = mapperUBO.AmbientColor;\n  var diffuseColor: vec4<f32> = mapperUBO.DiffuseColor;\n  var opacity: f32 = mapperUBO.Opacity;\n\n  //VTK::Color::Impl\n\n  //VTK::Normal::Impl\n\n  //VTK::Light::Impl\n\n  var computedColor: vec4<f32> = vec4<f32>(ambientColor.rgb * mapperUBO.AmbientIntensity\n     + diffuse * mapperUBO.DiffuseIntensity\n     + specular * mapperUBO.SpecularIntensity,\n     opacity);\n\n  //VTK::TCoord::Impl\n\n  //VTK::Select::Impl\n\n  if (computedColor.a == 0.0) { discard; };\n\n  //VTK::Position::Impl\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n";
+var vtkWebGPUPolyDataFS = "\nstruct PBRData {\n  diffuse: vec3<f32>,\n  specular: vec3<f32>,\n}\n\n// Dot product with the max already in it\nfn mdot(a: vec3<f32>, b: vec3<f32>) -> f32 {\n  return max(0.0, dot(a, b));\n}\n\n// Lambertian diffuse model\nfn lambertDiffuse(base: vec3<f32>, N: vec3<f32>, L: vec3<f32>) -> vec3<f32> {\n  var pi: f32 = 3.14159265359; \n  var NdotL: f32 = mdot(N, L);\n  NdotL = pow(NdotL, 1.5);\n  return (base/pi)*NdotL;\n}\n\n// Yasuhiro Fujii improvement on the Oren-Nayar model\n// https://mimosa-pudica.net/improved-oren-nayar.html\n// p is surface color, o is roughness\nfn fujiiOrenNayar(p: vec3<f32>, o: f32, N: vec3<f32>, L: vec3<f32>, V: vec3<f32>) -> vec3<f32> {\n  var invpi: f32 = 0.31830988618; // 1/pi\n\n  var o2 = o*o;\n  var NdotL: f32 = mdot(N, L);\n  NdotL = pow(NdotL, 1.5); // Less physically accurate, but hides the \"seams\" between lights better\n\n  var NdotV: f32 = mdot(N, V);\n  var LdotV: f32 = mdot(L, V);\n\n  var s: f32 = LdotV - NdotL*NdotV;\n  var t: f32 = mix(1, max(NdotL, NdotV), step(0, s)); // Mix with step is the equivalent of an if statement\n  var A: vec3<f32> = 0.5*(o2 / (o2 + 0.33)) + 0.17*p*(o2 / (o2 + 0.13));\n  A = invpi*(1 - A);\n  var B: f32 = 0.45*(o2 / (o2 + 0.09));\n  B = invpi*B;\n\n  return p*NdotL*(A + B*(s/t));\n}\n\n// Fresnel portion of BRDF (IOR only, simplified)\nfn schlickFresnelIOR(V: vec3<f32>, N: vec3<f32>, ior: f32, k: f32) -> f32 {\n  var NdotV: f32 = mdot(V, N);\n  // var R0: f32 = pow((ior - 1.0) / (ior + 1.0), 2); // 1.0 is about the ior of air, and it is assumed that light will be traveling through air\n  var F0: f32 = (pow((ior - 1.0), 2) + k*k) / (pow((ior + 1.0), 2) + k*k); // This takes into account the roughness, whic the other one does not\n  return F0 + (1 - F0) * pow((1-NdotV), 5); \n}\n\n// Fresnel portion of BRDF (Color ior, better)\nfn schlickFresnelRGB(V: vec3<f32>, N: vec3<f32>, F0: vec3<f32>) -> vec3<f32> {\n  var NdotV: f32 = mdot(V, N);\n  return F0 + (1 - F0) * pow((1-NdotV), 5); \n}\n\n// Normal portion of BRDF\n// https://learnopengl.com/PBR/Theory\n// Trowbridge-Reitz GGX functions: normal, halfway, roughness^2\nfn trGGX(N: vec3<f32>, H: vec3<f32>, a: f32) -> f32 {\n  var pi: f32 = 3.14159265359; \n\n  var a2: f32 = a*a;\n  var NdotH = mdot(N, H);\n  var NdotH2 = NdotH*NdotH;\n  \n  var denom: f32 = NdotH2 * (a2 - 1.0) + 1.0;\n\n  return a2 / max((pi*denom*denom), 0.000001);\n}\n\n// A VERY bad approximation of anisotropy. Real anisotropic calculations require tangent and bitangent\nfn anisotrophicTrGGX(N: vec3<f32>, H: vec3<f32>, O: vec3<f32>, s: f32, a: f32) -> f32 {\n  var Op: vec3<f32> = (rendererUBO.WCVCNormals * vec4<f32>(normalize(O) * s, 0.)).xyz;\n\n  var ggx1: f32 = trGGX(N + Op*s, H, a);\n  var ggx2: f32 = trGGX(N - Op*s, H, a);\n  return (0.5 * ggx1 + 0.5 * ggx2);\n}\n\n// Geometry portion of BRDF\nfn schlickGGX(N: vec3<f32>, X: vec3<f32>, k: f32) -> f32 {\n  var NdotX = mdot(N, X);\n  return NdotX / max(0.000001, (NdotX*(1-k) + k));\n}\n\nfn smithSurfaceRoughness(N: vec3<f32>, V: vec3<f32>, L: vec3<f32>, k: f32) -> f32 {\n  var ggx1: f32 = max(0.01, schlickGGX(N, V, k)); // Prevents void zones at the cost of some accuracy\n  var ggx2: f32 = schlickGGX(N, L, k);\n  return ggx1*ggx2;\n}\n\n// BRDF Combination\nfn cookTorrance(D: f32, F: f32, G: f32, N: vec3<f32>, V: vec3<f32>, L: vec3<f32>) -> f32 {\n  var num: f32 = D*F*G;\n  var denom: f32 = 4*mdot(V, N)*mdot(L, N);\n\n  return num / max(denom, 0.000001);\n}\n\n// Different lighting calculations for different light sources\nfn calcDirectionalLight(N: vec3<f32>, V: vec3<f32>, ior: f32, roughness: f32, metallic: f32, direction: vec3<f32>, color: vec3<f32>, base: vec3<f32>) -> PBRData {  \n  var L: vec3<f32> = normalize(direction); // Light Vector\n  var H: vec3<f32> = normalize(L + V); // Halfway Vector\n\n  var alpha = roughness*roughness;\n  var k: f32 = alpha*alpha / 2;\n\n  var D: f32 = trGGX(N, H, alpha); // Distribution\n  // var F: f32 = schlickFresnelIOR(V, N, ior, k); // Fresnel\n  var G: f32 = smithSurfaceRoughness(N, V, L, k); // Geometry\n\n  var brdf: f32 = cookTorrance(D, 1, G, N, V, L); // Fresnel term is replaced with 1 because it is added later\n  var incoming: vec3<f32> = color;\n  var angle: f32 = mdot(L, N);\n  angle = pow(angle, 1.5);\n\n  var specular: vec3<f32> = brdf*incoming*angle;\n  // 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\n  // control property for the diffuse vs specular roughness\n  var diffuse: vec3<f32> = incoming*fujiiOrenNayar(base, roughness, N, L, V); \n  // Stores the specular and diffuse separately to allow for finer post processing\n  // Could also be done (propably more properly) with a struct\n  var out = PBRData(diffuse, specular);\n  \n  return out; // Returns angle along with color of light so the final color can be multiplied by angle as well (creates black areas)\n}\n\n// TODO: find some way to reduce the number of arguments going in here\nfn 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 {\n  var L: vec3<f32> = normalize(position - fragPos); // Light Vector\n  var H: vec3<f32> = normalize(L + V); // Halfway Vector\n  var dist = distance(position, fragPos);\n\n  var alpha = roughness*roughness;\n  var k: f32 = alpha*alpha / 2; // could also be pow(alpha + 1.0, 2) / 8\n\n  var D: f32 = trGGX(N, H, alpha); // Distribution\n  // var F: f32 = schlickFresnelIOR(V, N, ior, k); // Fresnel\n  var G: f32 = smithSurfaceRoughness(N, V, L, k); // Geometry\n\n  var brdf: f32 = cookTorrance(D, 1, G, N, V, L);  \n  var incoming: vec3<f32> = color * (1. / (dist*dist));\n  var angle: f32 = mdot(L, N);\n  angle = pow(angle, 1.5); // Smoothing factor makes it less accurate, but reduces ugly \"seams\" bewteen light sources\n\n  var specular: vec3<f32> = brdf*incoming*angle;\n  var diffuse: vec3<f32> = incoming*fujiiOrenNayar(base, roughness, N, L, V);\n\n  // Stores the specular and diffuse separately to allow for finer post processing\n  // Could also be done (propably more properly) with a struct\n  var out = PBRData(diffuse, specular);\n  \n  return out; // Returns angle along with color of light so the final color can be multiplied by angle as well (creates black areas)\n}\n\n// For a reason unknown to me, spheres dont seem to behave propperly with head-on spot lights\nfn 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 {\n  var L: vec3<f32> = normalize(position - fragPos);\n  var H: vec3<f32> = normalize(L + V); // Halfway Vector\n  var dist = distance(position, fragPos);\n\n  var alpha = roughness*roughness;\n  var k: f32 = alpha*alpha / 2; // could also be pow(alpha + 1.0, 2) / 8\n\n  var D: f32 = trGGX(N, H, alpha); // Distribution\n  // var F: f32 = schlickFresnelIOR(V, N, ior, k); // Fresnel\n  var G: f32 = smithSurfaceRoughness(N, V, L, k); // Geometry\n\n  var brdf: f32 = cookTorrance(D, 1, G, N, V, L);  \n  \n  // Cones.x is the inner phi and cones.y is the outer phi\n  var theta: f32 = mdot(normalize(direction), L);\n  var epsilon: f32 = cones.x - cones.y;\n  var intensity: f32 = (theta - cones.y) / epsilon;\n  intensity = clamp(intensity, 0.0, 1.0);\n  intensity /= dist*dist;\n\n  var incoming: vec3<f32> = color * intensity;\n\n  var angle: f32 = mdot(L, N);\n  angle = pow(angle, 1.5); // Smoothing factor makes it less accurate, but reduces ugly \"seams\" bewteen light sources\n\n  var specular: vec3<f32> = brdf*incoming*angle;\n  var diffuse: vec3<f32> = incoming*fujiiOrenNayar(base, roughness, N, L, V);\n\n  // Stores the specular and diffuse separately to allow for finer post processing\n  // Could also be done (propably more properly) with a struct\n  var out = PBRData(diffuse, specular);\n  \n  return out; // Returns angle along with color of light so the final color can be multiplied by angle as well (creates black areas)\n}\n\n// Environment mapping stuff\n// Takes in a vector and converts it to an equivalent coordinate in a rectilinear texture. Should be replaced with cubemaps at some point\nfn vecToRectCoord(dir: vec3<f32>) -> vec2<f32> {\n  var tau: f32 = 6.28318530718;\n  var out: vec2<f32> = vec2<f32>(0.);\n\n  out.x = atan2(dir.z, dir.x) / tau;\n  out.x += 0.5;\n\n  out.y = (dir.y * .5) + .5;\n\n  return out;\n}\n\n//VTK::Renderer::Dec\n\n//VTK::Color::Dec\n\n//VTK::TCoord::Dec\n\n// optional surface normal declaration\n//VTK::Normal::Dec\n\n//VTK::Select::Dec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::IOStructs::Dec\n\n@fragment\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output : fragmentOutput;\n\n  // Temporary ambient, diffuse, and opacity\n  var ambientColor: vec4<f32> = mapperUBO.AmbientColor;\n  var diffuseColor: vec4<f32> = mapperUBO.DiffuseColor;\n  var opacity: f32 = mapperUBO.Opacity;\n\n  // This should be declared somewhere else\n  var _diffuseMap: vec4<f32> = vec4<f32>(1);\n  var _roughnessMap: vec4<f32> = vec4<f32>(1);\n  var _metallicMap: vec4<f32> = vec4<f32>(1);\n  var _normalMap: vec4<f32> = vec4<f32>(0, 0, 1, 0); // normal map was setting off the normal vector detection in fragment\n  var _ambientOcclusionMap: vec4<f32> = vec4<f32>(0);\n  var _emissionMap: vec4<f32> = vec4<f32>(0);\n\n  //VTK::Color::Impl\n\n  //VTK::TCoord::Impl\n\n  //VTK::Normal::Impl\n\n  var computedColor: vec4<f32> = vec4<f32>(diffuseColor.rgb, 1.);\n\n  //VTK::Light::Impl\n\n  //VTK::Select::Impl\n\n  if (computedColor.a == 0.0) { discard; };\n\n  //VTK::Position::Impl\n\n  //VTK::RenderEncoder::Impl\n\n  return output;\n}\n";
 
 function isEdges(hash) {
   // edge pipelines have "edge" in them
@@ -72,6 +72,9 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
     var utime = model.UBO.getSendTime();
 
     if (publicAPI.getMTime() > utime || ppty.getMTime() > utime || model.renderable.getMTime() > utime) {
+      var _ppty$getEdgeColorByR;
+
+      // Matricies
       var keyMats = model.WebGPUActor.getKeyMatrices(model.WebGPURenderer);
       model.UBO.setArray('BCWCMatrix', keyMats.bcwc);
       model.UBO.setArray('BCSCMatrix', keyMats.bcsc);
@@ -79,25 +82,42 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
 
       if (model.is2D) {
         model.UBO.setValue('ZValue', model.WebGPUActor.getRenderable().getProperty().getDisplayLocation() === DisplayLocation.FOREGROUND ? 1.0 : 0.0);
-        var aColor = ppty.getColorByReference();
+
+        var _aColor = ppty.getColorByReference();
+
         model.UBO.setValue('AmbientIntensity', 1.0);
-        model.UBO.setArray('AmbientColor', [aColor[0], aColor[1], aColor[2], 1.0]);
+        model.UBO.setArray('DiffuseColor', [_aColor[0], _aColor[1], _aColor[2], 1.0]);
         model.UBO.setValue('DiffuseIntensity', 0.0);
         model.UBO.setValue('SpecularIntensity', 0.0);
       } else {
-        var _aColor = ppty.getAmbientColorByReference();
+        // Base Colors
+        var _aColor2 = ppty.getAmbientColorByReference();
 
         model.UBO.setValue('AmbientIntensity', ppty.getAmbient());
-        model.UBO.setArray('AmbientColor', [_aColor[0], _aColor[1], _aColor[2], 1.0]);
+        model.UBO.setArray('AmbientColor', [_aColor2[0], _aColor2[1], _aColor2[2], 1.0]);
         model.UBO.setValue('DiffuseIntensity', ppty.getDiffuse());
-        _aColor = ppty.getDiffuseColorByReference();
-        model.UBO.setArray('DiffuseColor', [_aColor[0], _aColor[1], _aColor[2], 1.0]);
+        _aColor2 = ppty.getDiffuseColorByReference();
+        model.UBO.setArray('DiffuseColor', [_aColor2[0], _aColor2[1], _aColor2[2], 1.0]); // Roughness
+
+        model.UBO.setValue('Roughness', ppty.getRoughness());
+        model.UBO.setValue('BaseIOR', ppty.getBaseIOR()); // Metallic
+
+        model.UBO.setValue('Metallic', ppty.getMetallic()); // Normal
+
+        model.UBO.setValue('NormalStrength', ppty.getNormalStrength()); // Emission
+
+        model.UBO.setValue('Emission', ppty.getEmission()); // Specular
+
         model.UBO.setValue('SpecularIntensity', ppty.getSpecular());
-        model.UBO.setValue('SpecularPower', ppty.getSpecularPower());
-        _aColor = ppty.getSpecularColorByReference();
-        model.UBO.setArray('SpecularColor', [_aColor[0], _aColor[1], _aColor[2], 1.0]);
-        _aColor = ppty.getEdgeColorByReference();
-        model.UBO.setArray('EdgeColor', [_aColor[0], _aColor[1], _aColor[2], 1.0]);
+        _aColor2 = ppty.getSpecularColorByReference();
+        model.UBO.setArray('SpecularColor', [_aColor2[0], _aColor2[1], _aColor2[2], 1.0]);
+      } // Edge and line rendering
+
+
+      var aColor = (_ppty$getEdgeColorByR = ppty.getEdgeColorByReference) === null || _ppty$getEdgeColorByR === void 0 ? void 0 : _ppty$getEdgeColorByR.call(ppty);
+
+      if (aColor) {
+        model.UBO.setArray('EdgeColor', [aColor[0], aColor[1], aColor[2], 1.0]);
       }
 
       model.UBO.setValue('LineWidth', ppty.getLineWidth());
@@ -130,10 +150,11 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
   publicAPI.replaceShaderPosition = function (hash, pipeline, vertexInput) {
     var vDesc = pipeline.getShaderDescription('vertex');
     vDesc.addBuiltinOutput('vec4<f32>', '@builtin(position) Position');
+    if (!vDesc.hasOutput('vertexVC')) vDesc.addOutput('vec4<f32>', 'vertexVC');
     var code = vDesc.getCode();
 
     if (model.useRendererMatrix) {
-      code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['    var pCoord: vec4<f32> = rendererUBO.SCPCMatrix*mapperUBO.BCSCMatrix*vertexBC;', '//VTK::Position::Impl']).result;
+      code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['    var pCoord: vec4<f32> = rendererUBO.SCPCMatrix*mapperUBO.BCSCMatrix*vertexBC;', '    output.vertexVC = rendererUBO.SCVCMatrix * mapperUBO.BCSCMatrix * vec4<f32>(vertexBC.xyz, 1.0);', '//VTK::Position::Impl']).result;
 
       if (model.forceZValue) {
         code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['pCoord = vec4<f32>(pCoord.xyz/pCoord.w, 1.0);', 'pCoord.z = mapperUBO.ZValue;', '//VTK::Position::Impl']).result;
@@ -161,16 +182,38 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
 
   publicAPI.replaceShaderNormal = function (hash, pipeline, vertexInput) {
     var normalBuffer = vertexInput.getBuffer('normalMC');
+    var actor = model.WebGPUActor.getRenderable();
 
     if (normalBuffer) {
       var vDesc = pipeline.getShaderDescription('vertex');
-      vDesc.addOutput('vec3<f32>', 'normalVC', normalBuffer.getArrayInformation()[0].interpolation);
+
+      if (!vDesc.hasOutput('normalVC')) {
+        vDesc.addOutput('vec3<f32>', 'normalVC', normalBuffer.getArrayInformation()[0].interpolation);
+      }
+
+      if (!vDesc.hasOutput('tangentVC')) {
+        vDesc.addOutput('vec3<f32>', 'tangentVC', normalBuffer.getArrayInformation()[0].interpolation);
+      }
+
+      if (!vDesc.hasOutput('bitangentVC')) {
+        vDesc.addOutput('vec3<f32>', 'bitangentVC', normalBuffer.getArrayInformation()[0].interpolation);
+      }
+
       var code = vDesc.getCode();
-      code = vtkWebGPUShaderCache.substitute(code, '//VTK::Normal::Impl', ['  output.normalVC = normalize((rendererUBO.WCVCNormals * mapperUBO.MCWCNormals * normalMC).xyz);']).result;
+      code = vtkWebGPUShaderCache.substitute(code, '//VTK::Normal::Impl', ['  output.normalVC = normalize((rendererUBO.WCVCNormals * mapperUBO.MCWCNormals * normalMC).xyz);', // This is just an approximation, but it happens to work extremely well
+      // It only works well for normals that are head on and not super angled though
+      // Definitely needs to be replaced
+      '  var c1: vec3<f32> = cross(output.normalVC, vec3<f32>(0, 0, 1));', '  var c2: vec3<f32> = cross(output.normalVC, vec3<f32>(0, 1, 0));', '  var tangent: vec3<f32> = mix(c1, c2, distance(c1, c2));', '  output.tangentVC = normalize(tangent);', '  output.bitangentVC = normalize(cross(output.normalVC, tangent));']).result;
       vDesc.setCode(code);
       var fDesc = pipeline.getShaderDescription('fragment');
       code = fDesc.getCode();
-      code = vtkWebGPUShaderCache.substitute(code, '//VTK::Normal::Impl', ['  var normal: vec3<f32> = input.normalVC;', '  if (!input.frontFacing) { normal = -normal; }']).result;
+
+      if (actor.getProperty().getNormalTexture()) {
+        code = vtkWebGPUShaderCache.substitute(code, '//VTK::Normal::Impl', ['  var normal: vec3<f32> = input.normalVC;', '  if (!input.frontFacing) { normal = -normal; }', '  var tangent: vec3<f32> = input.tangentVC;', '  var bitangent: vec3<f32> = input.bitangentVC;', '  var TCVCMatrix: mat3x3<f32> = mat3x3<f32>(', '    tangent.x, bitangent.x, normal.x,', '    tangent.y, bitangent.y, normal.y,', '    tangent.z, bitangent.z, normal.z,', '  );', '  normal = TCVCMatrix * (_normalMap.xyz * 2 - 1);', '  normal = mix(input.normalVC, normal, mapperUBO.NormalStrength);', '  normal = normalize(normal);']).result;
+      } else {
+        code = vtkWebGPUShaderCache.substitute(code, '//VTK::Normal::Impl', ['  var normal: vec3<f32> = input.normalVC;', '  if (!input.frontFacing) { normal = -normal; }', '  normal = normalize(normal);']).result;
+      }
+
       fDesc.setCode(code);
     }
   };
@@ -179,14 +222,24 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
   // fragment shader code. That is the lighting trigger.
 
   publicAPI.replaceShaderLight = function (hash, pipeline, vertexInput) {
+    if (hash.includes('sel')) return;
+    var vDesc = pipeline.getShaderDescription('vertex');
+    if (!vDesc.hasOutput('vertexVC')) vDesc.addOutput('vec4<f32>', 'vertexVC');
     var fDesc = pipeline.getShaderDescription('fragment');
-    var code = fDesc.getCode();
-
-    if (code.includes('var normal')) {
-      code = vtkWebGPUShaderCache.substitute(code, '//VTK::Light::Impl', ['  var df: f32  = max(0.0, normal.z);', '  var sf: f32 = pow(df, mapperUBO.SpecularPower);', '  var diffuse: vec3<f32> = df * diffuseColor.rgb;', '  var specular: vec3<f32> = sf * mapperUBO.SpecularColor.rgb * mapperUBO.SpecularColor.a;']).result;
-      fDesc.setCode(code);
+    var code = fDesc.getCode(); // Code that runs if the fragment shader includes normals
+
+    if (code.includes('var normal:') && model.useRendererMatrix && !isEdges(hash) && !model.is2D && !hash.includes('sel')) {
+      code = vtkWebGPUShaderCache.substitute(code, '//VTK::Light::Impl', [// Constants
+      '  var pi: f32 = 3.14159265359;', // 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', // Values needed for light calculations
+      '  var baseColor: vec3<f32> = _diffuseMap.rgb * diffuseColor.rgb;', '  var roughness: f32 = 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;', // 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;', // 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++; }', '    }', '  }', // Final variables for combining specular and diffuse
+      '  var fresnel: f32 = schlickFresnelIOR(V, normal, ior, k); // Fresnel', '  fresnel = min(1, 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), 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);']).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;']).result;
+      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, mapperUBO.Opacity);']).result;
       fDesc.setCode(code);
     }
   };
@@ -194,6 +247,7 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
   model.shaderReplacements.set('replaceShaderLight', publicAPI.replaceShaderLight);
 
   publicAPI.replaceShaderColor = function (hash, pipeline, vertexInput) {
+    // By default, set the colors to be flat
     if (isEdges(hash)) {
       var _fDesc = pipeline.getShaderDescription('fragment');
 
@@ -204,15 +258,18 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
       _fDesc.setCode(_code);
 
       return;
-    }
+    } // If there's no vertex color buffer return the shader as is
+
 
     var colorBuffer = vertexInput.getBuffer('colorVI');
-    if (!colorBuffer) return;
+    if (!colorBuffer) return; // Modifies the vertex shader to include the vertex colors and interpolation in the outputs
+
     var vDesc = pipeline.getShaderDescription('vertex');
     vDesc.addOutput('vec4<f32>', 'color', colorBuffer.getArrayInformation()[0].interpolation);
     var code = vDesc.getCode();
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::Color::Impl', ['  output.color = colorVI;']).result;
-    vDesc.setCode(code);
+    vDesc.setCode(code); // Sets the fragment shader to accept the color inputs from the vertex shader
+
     var fDesc = pipeline.getShaderDescription('fragment');
     code = fDesc.getCode();
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::Color::Impl', ['ambientColor = input.color;', 'diffuseColor = input.color;', 'opacity = mapperUBO.Opacity * input.color.a;']).result;
@@ -222,27 +279,70 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
   model.shaderReplacements.set('replaceShaderColor', publicAPI.replaceShaderColor);
 
   publicAPI.replaceShaderTCoord = function (hash, pipeline, vertexInput) {
+    var _actor$getProperty$ge, _actor$getProperty, _actor$getProperty$ge2, _actor$getProperty$ge4, _actor$getProperty3, _actor$getProperty$ge5, _actor$getProperty$ge6, _actor$getProperty4, _actor$getProperty$ge7, _actor$getProperty$ge8, _actor$getProperty5, _actor$getProperty$ge9, _actor$getProperty$ge10, _actor$getProperty6, _actor$getProperty$ge11, _actor$getProperty$ge12, _actor$getProperty7, _actor$getProperty$ge13;
+
     if (!vertexInput.hasAttribute('tcoord')) return;
     var vDesc = pipeline.getShaderDescription('vertex');
     var tcoords = vertexInput.getBuffer('tcoord');
     var numComp = vtkWebGPUTypes.getNumberOfComponentsFromBufferFormat(tcoords.getArrayInformation()[0].format);
     var code = vDesc.getCode();
     vDesc.addOutput("vec".concat(numComp, "<f32>"), 'tcoordVS');
-    code = vtkWebGPUShaderCache.substitute(code, '//VTK::TCoord::Impl', ['  output.tcoordVS = tcoord;']).result;
+    code = vtkWebGPUShaderCache.substitute(code, '//VTK::TCoord::Impl', ['  output.tcoordVS = tcoord;' // Ensure that UV coordinates are always between 0-1
+    ]).result;
     vDesc.setCode(code);
+    if (model.is2D) return;
     var fDesc = pipeline.getShaderDescription('fragment');
-    code = fDesc.getCode(); // todo handle multiple textures? Blend multiply ?
+    code = fDesc.getCode();
+    var actor = model.WebGPUActor.getRenderable();
 
-    if (model.textures.length) {
-      var tdims = model.textures[0].getDimensions();
+    var checkDims = function checkDims(texture) {
+      if (!texture) return false;
+      var dims = texture.getDimensionality();
+      return dims === numComp;
+    };
 
-      if (tdims === numComp) {
-        code = vtkWebGPUShaderCache.substitute(code, '//VTK::TCoord::Impl', ['var tcolor: vec4<f32> = textureSample(Texture0, Texture0Sampler, input.tcoordVS);', 'computedColor = computedColor*tcolor;']).result;
-      } else {
-        console.log("mismatched texture coord dimension ".concat(numComp, " with texture map dimension ").concat(tdims));
+    var usedTextures = [];
+
+    if ((_actor$getProperty$ge = (_actor$getProperty = actor.getProperty()).getDiffuseTexture) !== null && _actor$getProperty$ge !== void 0 && (_actor$getProperty$ge2 = _actor$getProperty$ge.call(_actor$getProperty)) !== null && _actor$getProperty$ge2 !== void 0 && _actor$getProperty$ge2.getImageLoaded() || actor.getTextures()[0] || model.colorTexture) {
+      var _actor$getProperty$ge3, _actor$getProperty2;
+
+      if ( // Chained or statements here are questionable
+      checkDims((_actor$getProperty$ge3 = (_actor$getProperty2 = actor.getProperty()).getDiffuseTexture) === null || _actor$getProperty$ge3 === void 0 ? void 0 : _actor$getProperty$ge3.call(_actor$getProperty2)) || checkDims(actor.getTextures()[0]) || checkDims(model.colorTexture)) {
+        usedTextures.push('_diffuseMap = textureSample(DiffuseTexture, DiffuseTextureSampler, input.tcoordVS);');
+      }
+    }
+
+    if ((_actor$getProperty$ge4 = (_actor$getProperty3 = actor.getProperty()).getRoughnessTexture) !== null && _actor$getProperty$ge4 !== void 0 && (_actor$getProperty$ge5 = _actor$getProperty$ge4.call(_actor$getProperty3)) !== null && _actor$getProperty$ge5 !== void 0 && _actor$getProperty$ge5.getImageLoaded()) {
+      if (checkDims(actor.getProperty().getRoughnessTexture())) {
+        usedTextures.push('_roughnessMap = textureSample(RoughnessTexture, RoughnessTextureSampler, input.tcoordVS);');
+      }
+    }
+
+    if ((_actor$getProperty$ge6 = (_actor$getProperty4 = actor.getProperty()).getMetallicTexture) !== null && _actor$getProperty$ge6 !== void 0 && (_actor$getProperty$ge7 = _actor$getProperty$ge6.call(_actor$getProperty4)) !== null && _actor$getProperty$ge7 !== void 0 && _actor$getProperty$ge7.getImageLoaded()) {
+      if (checkDims(actor.getProperty().getMetallicTexture())) {
+        usedTextures.push('_metallicMap = textureSample(MetallicTexture, MetallicTextureSampler, input.tcoordVS);');
+      }
+    }
+
+    if ((_actor$getProperty$ge8 = (_actor$getProperty5 = actor.getProperty()).getNormalTexture) !== null && _actor$getProperty$ge8 !== void 0 && (_actor$getProperty$ge9 = _actor$getProperty$ge8.call(_actor$getProperty5)) !== null && _actor$getProperty$ge9 !== void 0 && _actor$getProperty$ge9.getImageLoaded()) {
+      if (checkDims(actor.getProperty().getNormalTexture())) {
+        usedTextures.push('_normalMap = textureSample(NormalTexture, NormalTextureSampler, input.tcoordVS);');
       }
     }
 
+    if ((_actor$getProperty$ge10 = (_actor$getProperty6 = actor.getProperty()).getAmbientOcclusionTexture) !== null && _actor$getProperty$ge10 !== void 0 && (_actor$getProperty$ge11 = _actor$getProperty$ge10.call(_actor$getProperty6)) !== null && _actor$getProperty$ge11 !== void 0 && _actor$getProperty$ge11.getImageLoaded()) {
+      if (checkDims(actor.getProperty().getAmbientOcclusionTexture())) {
+        usedTextures.push('_ambientOcclusionMap = textureSample(AmbientOcclusionTexture, AmbientOcclusionTextureSampler, input.tcoordVS);');
+      }
+    }
+
+    if ((_actor$getProperty$ge12 = (_actor$getProperty7 = actor.getProperty()).getEmissionTexture) !== null && _actor$getProperty$ge12 !== void 0 && (_actor$getProperty$ge13 = _actor$getProperty$ge12.call(_actor$getProperty7)) !== null && _actor$getProperty$ge13 !== void 0 && _actor$getProperty$ge13.getImageLoaded()) {
+      if (checkDims(actor.getProperty().getEmissionTexture())) {
+        usedTextures.push('_emissionMap = textureSample(EmissionTexture, EmissionTextureSampler, input.tcoordVS);');
+      }
+    }
+
+    code = vtkWebGPUShaderCache.substitute(code, '//VTK::TCoord::Impl', usedTextures).result;
     fDesc.setCode(code);
   };
 
@@ -309,7 +409,8 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
       default:
         return 'line-list';
     }
-  };
+  }; // TODO: calculate tangents
+
 
   publicAPI.buildVertexInput = function () {
     var _model$renderable$get, _model$renderable;
@@ -379,7 +480,9 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
 
     if (!model.is2D && ( // no lighting on Property2D
     usage === BufferUsage.Triangles || usage === BufferUsage.Strips)) {
-      var normals = pd.getPointData().getNormals();
+      var normals = pd.getPointData().getNormals(); // https://vtk.org/doc/nightly/html/classvtkPolyDataTangents.html
+      // Need to find some way of using precomputed tangents (or computing new ones)
+
       var _buffRequest2 = {
         format: 'snorm8x4',
         indexBuffer: indexBuffer,
@@ -466,7 +569,7 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
   };
 
   publicAPI.updateTextures = function () {
-    var _model$renderable$get2, _model$renderable2;
+    var _model$renderable$get2, _model$renderable2, _actor$getProperty$ge14, _actor$getProperty8, _actor$getProperty$ge15, _actor$getProperty9, _actor$getProperty$ge16, _actor$getProperty10, _actor$getProperty$ge17, _actor$getProperty11, _actor$getProperty$ge18, _actor$getProperty12, _actor$getProperty$ge19, _actor$getProperty13, _renderer$getBackgrou;
 
     // we keep track of new and used textures so
     // that we can clean up any unused textures so we don't hold onto them
@@ -483,28 +586,69 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
       }
 
       model.colorTexture.setInputData(idata);
-      newTextures.push(model.colorTexture);
+      newTextures.push(['Diffuse', model.colorTexture]);
     } // actor textures?
 
 
     var actor = model.WebGPUActor.getRenderable();
-    var textures = actor.getTextures();
+    var renderer = model.WebGPURenderer.getRenderable(); // Reusing the old code for new and old textures, just loading in from properties instead of actor.getTextures()
+
+    var textures = []; // Feels like there should be a better way than individually adding all
+
+    if ((_actor$getProperty$ge14 = (_actor$getProperty8 = actor.getProperty()).getDiffuseTexture) !== null && _actor$getProperty$ge14 !== void 0 && _actor$getProperty$ge14.call(_actor$getProperty8)) {
+      var pair = ['Diffuse', actor.getProperty().getDiffuseTexture()];
+      textures.push(pair);
+    }
+
+    if (actor.getTextures()[0]) {
+      var _pair = ['Diffuse', actor.getTextures()[0]];
+      textures.push(_pair);
+    }
+
+    if ((_actor$getProperty$ge15 = (_actor$getProperty9 = actor.getProperty()).getRoughnessTexture) !== null && _actor$getProperty$ge15 !== void 0 && _actor$getProperty$ge15.call(_actor$getProperty9)) {
+      var _pair2 = ['Roughness', actor.getProperty().getRoughnessTexture()];
+      textures.push(_pair2);
+    }
+
+    if ((_actor$getProperty$ge16 = (_actor$getProperty10 = actor.getProperty()).getMetallicTexture) !== null && _actor$getProperty$ge16 !== void 0 && _actor$getProperty$ge16.call(_actor$getProperty10)) {
+      var _pair3 = ['Metallic', actor.getProperty().getMetallicTexture()];
+      textures.push(_pair3);
+    }
+
+    if ((_actor$getProperty$ge17 = (_actor$getProperty11 = actor.getProperty()).getNormalTexture) !== null && _actor$getProperty$ge17 !== void 0 && _actor$getProperty$ge17.call(_actor$getProperty11)) {
+      var _pair4 = ['Normal', actor.getProperty().getNormalTexture()];
+      textures.push(_pair4);
+    }
+
+    if ((_actor$getProperty$ge18 = (_actor$getProperty12 = actor.getProperty()).getAmbientOcclusionTexture) !== null && _actor$getProperty$ge18 !== void 0 && _actor$getProperty$ge18.call(_actor$getProperty12)) {
+      var _pair5 = ['AmbientOcclusion', actor.getProperty().getAmbientOcclusionTexture()];
+      textures.push(_pair5);
+    }
+
+    if ((_actor$getProperty$ge19 = (_actor$getProperty13 = actor.getProperty()).getEmissionTexture) !== null && _actor$getProperty$ge19 !== void 0 && _actor$getProperty$ge19.call(_actor$getProperty13)) {
+      var _pair6 = ['Emission', actor.getProperty().getEmissionTexture()];
+      textures.push(_pair6);
+    }
+
+    if ((_renderer$getBackgrou = renderer.getBackgroundTexture) !== null && _renderer$getBackgrou !== void 0 && _renderer$getBackgrou.call(renderer)) {
+      var _pair7 = ['Background', renderer.getBackgroundTexture()];
+      textures.push(_pair7);
+    }
 
     for (var i = 0; i < textures.length; i++) {
-      if (textures[i].getInputData() || textures[i].getJsImageData() || textures[i].getCanvas()) {
+      if (textures[i][1].getInputData() || textures[i][1].getJsImageData() || textures[i][1].getCanvas()) {
         newTextures.push(textures[i]);
       }
 
-      if (textures[i].getImage() && textures[i].getImageLoaded()) {
+      if (textures[i][1].getImage() && textures[i][1].getImageLoaded()) {
         newTextures.push(textures[i]);
       }
     }
 
-    var usedCount = 0;
-
     for (var _i = 0; _i < newTextures.length; _i++) {
-      var srcTexture = newTextures[_i];
-      var newTex = model.device.getTextureManager().getTextureForVTKTexture(srcTexture);
+      var srcTexture = newTextures[_i][1];
+      var textureName = newTextures[_i][0];
+      var newTex = model.device.getTextureManager().getTextureForVTKTexture(srcTexture); // Generates hash
 
       if (newTex.getReady()) {
         // is this a new texture
@@ -512,7 +656,6 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
 
         for (var t = 0; t < model.textures.length; t++) {
           if (model.textures[t] === newTex) {
-            usedCount++;
             found = true;
             usedTextures[t] = true;
           }
@@ -520,7 +663,7 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
 
         if (!found) {
           usedTextures[model.textures.length] = true;
-          var tview = newTex.createView("Texture".concat(usedCount++));
+          var tview = newTex.createView("".concat(textureName, "Texture"));
           model.textures.push(newTex);
           model.textureViews.push(tview);
           var interpolate = srcTexture.getInterpolate() ? 'linear' : 'nearest';
@@ -623,14 +766,15 @@ var DEFAULT_VALUES = {
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+  var initiaLalues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initiaLalues); // Inheritance
 
-  vtkWebGPUSimpleMapper.extend(publicAPI, model, initialValues);
+  vtkWebGPUSimpleMapper.extend(publicAPI, model, initiaLalues);
   model.fragmentShaderTemplate = vtkWebGPUPolyDataFS;
   model.vertexShaderTemplate = vtkWebGPUPolyDataVS;
   model._tmpMat3 = mat3.identity(new Float64Array(9));
-  model._tmpMat4 = mat4.identity(new Float64Array(16));
+  model._tmpMat4 = mat4.identity(new Float64Array(16)); // UBO
+
   model.UBO = vtkWebGPUUniformBuffer.newInstance({
     label: 'mapperUBO'
   });
@@ -643,12 +787,21 @@ function extend(publicAPI, model) {
   model.UBO.addEntry('SpecularColor', 'vec4<f32>');
   model.UBO.addEntry('AmbientIntensity', 'f32');
   model.UBO.addEntry('DiffuseIntensity', 'f32');
+  model.UBO.addEntry('Roughness', 'f32');
+  model.UBO.addEntry('Metallic', 'f32');
+  model.UBO.addEntry('Ambient', 'f32');
+  model.UBO.addEntry('Normal', 'f32');
+  model.UBO.addEntry('Emission', 'f32');
+  model.UBO.addEntry('NormalStrength', 'f32');
+  model.UBO.addEntry('BaseIOR', 'f32');
   model.UBO.addEntry('SpecularIntensity', 'f32');
   model.UBO.addEntry('LineWidth', 'f32');
   model.UBO.addEntry('Opacity', 'f32');
-  model.UBO.addEntry('SpecularPower', 'f32');
   model.UBO.addEntry('ZValue', 'f32');
-  model.UBO.addEntry('PropID', 'u32'); // Build VTK API
+  model.UBO.addEntry('PropID', 'u32');
+  model.UBO.addEntry('ClipNear', 'f32');
+  model.UBO.addEntry('ClipFar', 'f32');
+  model.UBO.addEntry('Time', 'u32'); // Build VTK API
 
   setGet(publicAPI, model, ['cellArray', 'currentInput', 'cellOffset', 'is2D', 'primitiveType', 'renderEncoder']);
   model.textures = []; // Object methods

package/Rendering/WebGPU/Glyph3DMapper.js

@@ -29,8 +29,9 @@ function vtkWebGPUGlyph3DCellArrayMapper(publicAPI, model) {
     var vDesc = pipeline.getShaderDescription('vertex');
     vDesc.addBuiltinInput('u32', '@builtin(instance_index) instanceIndex');
     vDesc.addBuiltinOutput('vec4<f32>', '@builtin(position) Position');
+    if (!vDesc.hasOutput('vertexVC')) vDesc.addOutput('vec3<f32>', 'vertexVC');
     var code = vDesc.getCode();
-    code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['    output.Position = rendererUBO.SCPCMatrix*mapperUBO.BCSCMatrix', '      *glyphSSBO.values[input.instanceIndex].matrix', '      *vertexBC;']).result;
+    code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['    var vertexSC: vec4<f32> = mapperUBO.BCSCMatrix*glyphSSBO.values[input.instanceIndex].matrix*vertexBC;', '    output.vertexVC = (rendererUBO.SCVCMatrix*vertexSC).xyz;', '    output.Position = rendererUBO.SCPCMatrix*vertexSC;']).result;
     vDesc.setCode(code);
   };
 

package/Rendering/WebGPU/Renderer.js

@@ -1,18 +1,41 @@
 import { mat4, vec3 } from 'gl-matrix';
 import { newInstance as newInstance$1, obj, get, getArray, setGet, vtkDebugMacro as vtkDebugMacro$1 } from '../../macros.js';
+import { r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import vtkWebGPUBindGroup from './BindGroup.js';
 import vtkWebGPUFullScreenQuad from './FullScreenQuad.js';
+import vtkWebGPUStorageBuffer from './StorageBuffer.js';
 import vtkWebGPUUniformBuffer from './UniformBuffer.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
 var vtkDebugMacro = vtkDebugMacro$1;
-var clearFragTemplate = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::IOStructs::Dec\n\n@fragment\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output: fragmentOutput;\n\n  var computedColor: vec4<f32> = mapperUBO.BackgroundColor;\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n"; // ----------------------------------------------------------------------------
+var clearFragTemplate = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::IOStructs::Dec\n\n@fragment\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output: fragmentOutput;\n\n  var computedColor: vec4<f32> = mapperUBO.BackgroundColor;\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n"; // Light type index gives either 0, 1, or 2 which indicates what type of light there is.
+// While technically, there are only spot and directional lights, within the CellArrayMapper
+// there is a third, positional light. It is technically just a variant of a spot light with
+// a cone angle of 90 or above, however certain calculations can be skipped if it is treated
+// separately.
+// The mappings are shown below:
+// 0 -> positional light
+// 1 -> directional light
+// 2 -> spot light
+
+function getLightTypeIndex(light) {
+  if (light.getPositional()) {
+    if (light.getConeAngle() >= 90) {
+      return 0;
+    }
+
+    return 2;
+  }
+
+  return 1;
+} // ----------------------------------------------------------------------------
 // vtkWebGPURenderer methods
 // ----------------------------------------------------------------------------
 
 /* eslint-disable no-bitwise */
 
+
 function vtkWebGPURenderer(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPURenderer'); // Builds myself.
@@ -108,6 +131,7 @@ function vtkWebGPURenderer(publicAPI, model) {
       model.UBO.setArray('SCVCMatrix', keyMats.scvc);
       model.UBO.setArray('VCPCMatrix', keyMats.vcpc);
       model.UBO.setArray('WCVCNormals', keyMats.normalMatrix);
+      model.UBO.setValue('LightCount', model.renderable.getLights().length);
       var tsize = publicAPI.getYInvertedTiledSizeAndOrigin();
       model.UBO.setArray('viewportSize', [tsize.usize, tsize.vsize]);
       model.UBO.setValue('cameraParallel', model.camera.getParallelProjection());
@@ -118,6 +142,79 @@ function vtkWebGPURenderer(publicAPI, model) {
     }
   };
 
+  publicAPI.updateSSBO = function () {
+    var lights = model.renderable.getLights();
+    var keyMats = model.webgpuCamera.getKeyMatrices(publicAPI);
+    var lightTimeString = "".concat(model.renderable.getMTime());
+
+    for (var i = 0; i < lights.length; i++) {
+      lightTimeString += lights[i].getMTime();
+    }
+
+    if (lightTimeString !== model.lightTimeString) {
+      var lightPosArray = new Float32Array(lights.length * 4);
+      var lightDirArray = new Float32Array(lights.length * 4);
+      var lightColorArray = new Float32Array(lights.length * 4);
+      var lightTypeArray = new Float32Array(lights.length * 4);
+
+      for (var _i = 0; _i < lights.length; _i++) {
+        var offset = _i * 4; // Position
+
+        var viewCoordinatePosition = lights[_i].getPosition();
+
+        vec3.transformMat4(viewCoordinatePosition, viewCoordinatePosition, keyMats.wcvc); // console.log(viewCoordinatePosition);
+        // viewCoordinatePosition
+
+        lightPosArray[offset] = viewCoordinatePosition[0];
+        lightPosArray[offset + 1] = viewCoordinatePosition[1];
+        lightPosArray[offset + 2] = viewCoordinatePosition[2];
+        lightPosArray[offset + 3] = 0; // Rotation (All are negative to correct for -Z being forward)
+
+        lightDirArray[offset] = -lights[_i].getDirection()[0];
+        lightDirArray[offset + 1] = -lights[_i].getDirection()[1];
+        lightDirArray[offset + 2] = -lights[_i].getDirection()[2];
+        lightDirArray[offset + 3] = 0; // Color
+
+        lightColorArray[offset] = lights[_i].getColor()[0];
+        lightColorArray[offset + 1] = lights[_i].getColor()[1];
+        lightColorArray[offset + 2] = lights[_i].getColor()[2];
+        lightColorArray[offset + 3] = lights[_i].getIntensity() * 5; // arbitrary multiplication to fix the dullness of low value PBR lights
+        // Type
+
+        lightTypeArray[offset] = getLightTypeIndex(lights[_i]); // Type
+
+        lightTypeArray[offset + 1] = Math.cos(radiansFromDegrees(lights[_i].getConeAngle())); // Inner Phi, should probably do some check on these to make sure they dont excede limits
+
+        lightTypeArray[offset + 2] = Math.cos(radiansFromDegrees(lights[_i].getConeAngle() + lights[_i].getConeFalloff())); // Outer Phi
+
+        lightTypeArray[offset + 3] = 0;
+      } // Im not sure how correct this is, but this is what the example does
+      // https://kitware.github.io/vtk-js/api/Rendering_WebGPU_VolumePassFSQ.html
+
+
+      model.SSBO.clearData();
+      model.SSBO.setNumberOfInstances(lights.length);
+      model.SSBO.addEntry('LightPos', 'vec4<f32>'); // Position
+
+      model.SSBO.addEntry('LightDir', 'vec4<f32>'); // Direction
+
+      model.SSBO.addEntry('LightColor', 'vec4<f32>'); // Color (r, g, b, intensity)
+
+      model.SSBO.addEntry('LightData', 'vec4<f32>'); // Other data (type, etc, etc, etc)
+
+      model.SSBO.setAllInstancesFromArray('LightPos', lightPosArray);
+      model.SSBO.setAllInstancesFromArray('LightDir', lightDirArray);
+      model.SSBO.setAllInstancesFromArray('LightColor', lightColorArray);
+      model.SSBO.setAllInstancesFromArray('LightData', lightTypeArray);
+
+      var device = model._parent.getDevice();
+
+      model.SSBO.send(device);
+    }
+
+    model.lightTimeString = lightTimeString;
+  };
+
   publicAPI.scissorAndViewport = function (encoder) {
     var tsize = publicAPI.getYInvertedTiledSizeAndOrigin();
     encoder.getHandle().setViewport(tsize.lowerLeftU, tsize.lowerLeftV, tsize.usize, tsize.vsize, 0.0, 1.0); // set scissor
@@ -134,6 +231,7 @@ function vtkWebGPURenderer(publicAPI, model) {
     if (prepass) {
       model.renderEncoder.begin(model._parent.getCommandEncoder());
       publicAPI.updateUBO();
+      publicAPI.updateSSBO();
     } else {
       publicAPI.scissorAndViewport(model.renderEncoder);
       publicAPI.clear();
@@ -284,7 +382,8 @@ function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
 
-  vtkViewNode.extend(publicAPI, model, initialValues);
+  vtkViewNode.extend(publicAPI, model, initialValues); // UBO
+
   model.UBO = vtkWebGPUUniformBuffer.newInstance({
     label: 'rendererUBO'
   });
@@ -295,11 +394,17 @@ function extend(publicAPI, model) {
   model.UBO.addEntry('VCPCMatrix', 'mat4x4<f32>');
   model.UBO.addEntry('WCVCNormals', 'mat4x4<f32>');
   model.UBO.addEntry('viewportSize', 'vec2<f32>');
-  model.UBO.addEntry('cameraParallel', 'u32');
+  model.UBO.addEntry('LightCount', 'i32');
+  model.UBO.addEntry('cameraParallel', 'u32'); // SSBO (Light data)
+
+  model.SSBO = vtkWebGPUStorageBuffer.newInstance({
+    label: 'rendererLightSSBO'
+  });
+  model.lightTimeString = '';
   model.bindGroup = vtkWebGPUBindGroup.newInstance({
     label: 'rendererBG'
   });
-  model.bindGroup.setBindables([model.UBO]);
+  model.bindGroup.setBindables([model.UBO, model.SSBO]);
   model.tmpMat4 = mat4.identity(new Float64Array(16));
   model.stabilizedTime = {};
   obj(model.stabilizedTime, {

package/Rendering/WebGPU/SphereMapper.js

@@ -7,7 +7,7 @@ import { registerOverride } from './ViewNodeFactory.js';
 
 var BufferUsage = vtkWebGPUBufferManager.BufferUsage;
 var vtkErrorMacro = vtkErrorMacro$1;
-var vtkWebGPUSphereMapperVS = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::Color::Dec\n\n//VTK::IOStructs::Dec\n\n@vertex\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output : vertexOutput;\n\n  var vertexVC: vec4<f32> = rendererUBO.SCVCMatrix * mapperUBO.BCSCMatrix * vec4<f32>(vertexBC.x, vertexBC.y, vertexBC.z, 1.0);\n\n  //VTK::Color::Impl\n\n  // compute the projected vertex position\n  output.centerVC = vertexVC.xyz;\n  output.radiusVC = length(offsetMC)*0.5;\n\n  // make the triangle face the camera\n  if (rendererUBO.cameraParallel == 0u)\n    {\n    var dir: vec3<f32> = normalize(-vertexVC.xyz);\n    var base2: vec3<f32> = normalize(cross(dir,vec3<f32>(1.0,0.0,0.0)));\n    var base1: vec3<f32> = cross(base2,dir);\n    dir = vertexVC.xyz + offsetMC.x*base1 + offsetMC.y*base2;\n    vertexVC = vec4<f32>(dir, 1.0);\n    }\n  else\n    {\n    // add in the offset\n    var tmp2: vec2<f32> = vertexVC.xy + offsetMC;\n    vertexVC = vec4<f32>(tmp2, vertexVC.zw);\n    }\n\n  output.vertexVC = vertexVC.xyz;\n\n  //VTK::Position::Impl\n\n  return output;\n}\n"; // ----------------------------------------------------------------------------
+var vtkWebGPUSphereMapperVS = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::Color::Dec\n\n//VTK::IOStructs::Dec\n\n@vertex\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output : vertexOutput;\n\n  var vertexVC: vec4<f32> = rendererUBO.SCVCMatrix * mapperUBO.BCSCMatrix * vec4<f32>(vertexBC.xyz, 1.0);\n\n  //VTK::Color::Impl\n\n  // compute the projected vertex position\n  output.centerVC = vertexVC.xyz;\n  output.radiusVC = length(offsetMC)*0.5;\n\n  // make the triangle face the camera\n  if (rendererUBO.cameraParallel == 0u)\n    {\n    var dir: vec3<f32> = normalize(-vertexVC.xyz);\n    var base2: vec3<f32> = normalize(cross(dir,vec3<f32>(1.0,0.0,0.0)));\n    var base1: vec3<f32> = cross(base2,dir);\n    dir = vertexVC.xyz + offsetMC.x*base1 + offsetMC.y*base2;\n    vertexVC = vec4<f32>(dir, 1.0);\n    }\n  else\n    {\n    // add in the offset\n    var tmp2: vec2<f32> = vertexVC.xy + offsetMC;\n    vertexVC = vec4<f32>(tmp2, vertexVC.zw);\n    }\n\n  output.vertexVC = vec4<f32>(vertexVC.xyz, 0.0);\n\n  //VTK::Position::Impl\n\n  return output;\n}\n"; // ----------------------------------------------------------------------------
 // vtkWebGPUSphereMapper methods
 // ----------------------------------------------------------------------------
 
@@ -32,7 +32,7 @@ function vtkWebGPUSphereMapper(publicAPI, model) {
 
   publicAPI.replaceShaderNormal = function (hash, pipeline, vertexInput) {
     var vDesc = pipeline.getShaderDescription('vertex');
-    vDesc.addOutput('vec3<f32>', 'vertexVC');
+    if (!vDesc.hasOutput('vertexVC')) vDesc.addOutput('vec4<f32>', 'vertexVC');
     vDesc.addOutput('vec3<f32>', 'centerVC');
     vDesc.addOutput('f32', 'radiusVC');
     var fDesc = pipeline.getShaderDescription('fragment');

package/Rendering/WebGPU/StickMapper.js

@@ -26,7 +26,7 @@ var vtkErrorMacro = vtkErrorMacro$1; // Vertices
 // 4: 011
 // 5: 111
 
-var vtkWebGPUStickMapperVS = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::Color::Dec\n\n//VTK::IOStructs::Dec\n\n@vertex\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var offsetsArray: array<vec3<f32>, 12> = array<vec3<f32>, 12>(\n    vec3<f32>(-1.0, -1.0, -1.0),\n    vec3<f32>(1.0, -1.0, -1.0),\n    vec3<f32>(1.0, -1.0, 1.0),\n\n    vec3<f32>(-1.0, -1.0, -1.0),\n    vec3<f32>(1.0, -1.0, 1.0),\n    vec3<f32>(-1.0, -1.0, 1.0),\n\n    vec3<f32>(-1.0, -1.0, 1.0),\n    vec3<f32>(1.0, -1.0, 1.0),\n    vec3<f32>(1.0, 1.0, 1.0),\n\n    vec3<f32>(-1.0, -1.0, 1.0),\n    vec3<f32>(1.0, 1.0, 1.0),\n    vec3<f32>(-1.0, 1.0, 1.0)\n  );\n\n  var output : vertexOutput;\n\n  var vertexVC: vec4<f32> = rendererUBO.SCVCMatrix * mapperUBO.BCSCMatrix * vec4<f32>(vertexBC.x, vertexBC.y, vertexBC.z, 1.0);\n\n  //VTK::Color::Impl\n\n  // compute the projected vertex position\n  output.centerVC = vertexVC.xyz;\n  output.radiusVC = radiusMC;\n  output.lengthVC = length(orientMC);\n  output.orientVC = (rendererUBO.WCVCNormals * vec4<f32>(normalize(orientMC), 0.0)).xyz;\n\n  // make sure it is pointing out of the screen\n  if (output.orientVC.z < 0.0)\n    {\n    output.orientVC = -output.orientVC;\n    }\n\n  // make the basis\n  var xbase: vec3<f32>;\n  var ybase: vec3<f32>;\n  var dir: vec3<f32> = vec3<f32>(0.0,0.0,1.0);\n  if (rendererUBO.cameraParallel == 0u)\n    {\n    dir = normalize(-vertexVC.xyz);\n    }\n  if (abs(dot(dir,output.orientVC)) == 1.0)\n    {\n    xbase = normalize(cross(vec3<f32>(0.0,1.0,0.0),output.orientVC));\n    ybase = cross(xbase,output.orientVC);\n    }\n  else\n    {\n    xbase = normalize(cross(output.orientVC,dir));\n    ybase = cross(output.orientVC,xbase);\n    }\n\n\n  var vertIdx: u32 = input.vertexIndex % 12u;\n  var offsets: vec3<f32> = offsetsArray[vertIdx];\n\n  vertexVC = vec4<f32>(vertexVC.xyz +\n    output.radiusVC * offsets.x * xbase +\n    output.radiusVC * offsets.y * ybase +\n    0.5 * output.lengthVC * offsets.z * output.orientVC, 1.0);\n\n  output.vertexVC = vertexVC;\n\n  //VTK::Position::Impl\n\n  return output;\n}\n"; // ----------------------------------------------------------------------------
+var vtkWebGPUStickMapperVS = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::Color::Dec\n\n//VTK::IOStructs::Dec\n\n@vertex\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var offsetsArray: array<vec3<f32>, 12> = array<vec3<f32>, 12>(\n    vec3<f32>(-1.0, -1.0, -1.0),\n    vec3<f32>(1.0, -1.0, -1.0),\n    vec3<f32>(1.0, -1.0, 1.0),\n\n    vec3<f32>(-1.0, -1.0, -1.0),\n    vec3<f32>(1.0, -1.0, 1.0),\n    vec3<f32>(-1.0, -1.0, 1.0),\n\n    vec3<f32>(-1.0, -1.0, 1.0),\n    vec3<f32>(1.0, -1.0, 1.0),\n    vec3<f32>(1.0, 1.0, 1.0),\n\n    vec3<f32>(-1.0, -1.0, 1.0),\n    vec3<f32>(1.0, 1.0, 1.0),\n    vec3<f32>(-1.0, 1.0, 1.0)\n  );\n\n  var output : vertexOutput;\n\n  var vertexVC: vec4<f32> = rendererUBO.SCVCMatrix * mapperUBO.BCSCMatrix * vec4<f32>(vertexBC.xyz, 1.0);\n\n  //VTK::Color::Impl\n\n  // compute the projected vertex position\n  output.centerVC = vertexVC.xyz;\n  output.radiusVC = radiusMC;\n  output.lengthVC = length(orientMC);\n  output.orientVC = (rendererUBO.WCVCNormals * vec4<f32>(normalize(orientMC), 0.0)).xyz;\n\n  // make sure it is pointing out of the screen\n  if (output.orientVC.z < 0.0)\n    {\n    output.orientVC = -output.orientVC;\n    }\n\n  // make the basis\n  var xbase: vec3<f32>;\n  var ybase: vec3<f32>;\n  var dir: vec3<f32> = vec3<f32>(0.0,0.0,1.0);\n  if (rendererUBO.cameraParallel == 0u)\n    {\n    dir = normalize(-vertexVC.xyz);\n    }\n  if (abs(dot(dir,output.orientVC)) == 1.0)\n    {\n    xbase = normalize(cross(vec3<f32>(0.0,1.0,0.0),output.orientVC));\n    ybase = cross(xbase,output.orientVC);\n    }\n  else\n    {\n    xbase = normalize(cross(output.orientVC,dir));\n    ybase = cross(output.orientVC,xbase);\n    }\n\n\n  var vertIdx: u32 = input.vertexIndex % 12u;\n  var offsets: vec3<f32> = offsetsArray[vertIdx];\n\n  vertexVC = vec4<f32>(vertexVC.xyz +\n    output.radiusVC * offsets.x * xbase +\n    output.radiusVC * offsets.y * ybase +\n    0.5 * output.lengthVC * offsets.z * output.orientVC, 1.0);\n\n  output.vertexVC = vertexVC;\n\n  //VTK::Position::Impl\n\n  return output;\n}\n"; // ----------------------------------------------------------------------------
 // vtkWebGPUStickMapper methods
 // ----------------------------------------------------------------------------
 
@@ -51,7 +51,7 @@ function vtkWebGPUStickMapper(publicAPI, model) {
 
   publicAPI.replaceShaderNormal = function (hash, pipeline, vertexInput) {
     var vDesc = pipeline.getShaderDescription('vertex');
-    vDesc.addOutput('vec4<f32>', 'vertexVC');
+    if (!vDesc.hasOutput('vertexVC')) vDesc.addOutput('vec4<f32>', 'vertexVC');
     vDesc.addOutput('vec3<f32>', 'centerVC');
     vDesc.addOutput('vec3<f32>', 'orientVC');
     vDesc.addOutput('f32', 'radiusVC');

package/Rendering/WebGPU/Texture.js

@@ -184,8 +184,12 @@ function vtkWebGPUTexture(publicAPI, model) {
     return tDetails.numComponents;
   };
 
-  publicAPI.getDimensions = function () {
-    return model.depth > 1 ? 3 : 2;
+  publicAPI.getDimensionality = function () {
+    var dims = 0;
+    if (model.width > 1) dims++;
+    if (model.height > 1) dims++;
+    if (model.depth > 1) dims++;
+    return dims;
   };
 
   publicAPI.resizeToMatch = function (tex) {

package/package.json

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