@kitware/vtk.js 25.1.1 → 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/Actor2D.js

@@ -98,6 +98,8 @@ function vtkWebGPUActor2D(publicAPI, model) {
 
       if (model.renderable.getCoordinateSystem() === CoordinateSystem.WORLD) {
         mat4.translate(model.keyMatrices.bcsc, model.keyMatrices.bcwc, [-center[0], -center[1], -center[2]]);
+      } else {
+        mat4.copy(model.keyMatrices.bcsc, model.keyMatrices.bcwc);
       }
 
       model.keyMatricesTime.modified();

package/Rendering/WebGPU/BufferManager.js

@@ -65,7 +65,7 @@ function _getFormatForDataArray(dataArray) {
 
     case 3:
       // only 32bit types support x3
-      if (!format.contains('32')) {
+      if (!format.includes('32')) {
         vtkErrorMacro("unsupported x3 type for ".concat(format));
       }