@kitware/vtk.js 33.1.1 → 33.2.0

package/IO/Geometry/GLTFImporter/Reader.js

@@ -208,16 +208,15 @@ async function createPropertyFromGLTFMaterial(model, material, actor) {
         property.setDiffuseTexture(diffuseTex);
       }
     }
+
+    // Handle metallic-roughness texture (metallicRoughnessTexture)
     if (pbr.metallicRoughnessTexture) {
       pbr.metallicRoughnessTexture.extensions;
       const tex = pbr.metallicRoughnessTexture.texture;
       const sampler = tex.sampler;
-      const metallicImage = await loadImage(tex.source, 'b');
-      const metallicTex = createVTKTextureFromGLTFTexture(metallicImage, sampler);
-      property.setMetallicTexture(metallicTex);
-      const roughnessImage = await loadImage(tex.source, 'g');
-      const roughnessTex = createVTKTextureFromGLTFTexture(roughnessImage, sampler);
-      property.setRoughnessTexture(roughnessTex);
+      const rmImage = await loadImage(tex.source);
+      const rmTex = createVTKTextureFromGLTFTexture(rmImage, sampler);
+      property.setRMTexture(rmTex);
     }
 
     // Handle ambient occlusion texture (occlusionTexture)

package/Rendering/Core/Property.d.ts

@@ -1,5 +1,5 @@
 import { vtkObject } from './../../interfaces';
-import { RGBColor } from './../../types';
+import { Nullable, RGBColor } from './../../types';
 import { Interpolation, Representation, Shading } from './Property/Constants';
 import { vtkTexture } from './Texture';
 
@@ -14,6 +14,8 @@ export interface IPropertyInitialValues {
   normalTexture?: vtkTexture;
   ambientOcclusionTexture?: vtkTexture;
   emissionTexture?: vtkTexture;
+  RMTexture?: vtkTexture;
+  ORMTexture?: vtkTexture;
   edgeColor?: RGBColor;
   ambient?: number;
   diffuse?: number;
@@ -216,32 +218,42 @@ export interface vtkProperty extends vtkObject {
   /**
    * Get the diffuse texture.
    */
-  getDiffuseTexture(): vtkTexture;
+  getDiffuseTexture(): Nullable<vtkTexture>;
 
   /**
    * Get the metallic texture.
    */
-  getMetallicTexture(): vtkTexture;
+  getMetallicTexture(): Nullable<vtkTexture>;
+
+  /**
+   * Get the roughness & metallic texture.
+   */
+  getRMTexture(): Nullable<vtkTexture>;
+
+  /**
+   * Get the occlusion, roughness & metallic texture.
+   */
+  getORMTexture(): Nullable<vtkTexture>;
 
   /**
    * Get the roughness texture.
    */
-  getRoughnessTexture(): vtkTexture;
+  getRoughnessTexture(): Nullable<vtkTexture>;
 
   /**
    * Get the normal texture.
    */
-  getNormalTexture(): vtkTexture;
+  getNormalTexture(): Nullable<vtkTexture>;
 
   /**
    * Get the ambient occlusion texture.
    */
-  getAmbientOcclusionTexture(): vtkTexture;
+  getAmbientOcclusionTexture(): Nullable<vtkTexture>;
 
   /**
    * Get the emission texture.
    */
-  getEmissionTexture(): vtkTexture;
+  getEmissionTexture(): Nullable<vtkTexture>;
 
   /**
    * Set the ambient lighting coefficient.
@@ -500,6 +512,18 @@ export interface vtkProperty extends vtkObject {
    */
   setRoughnessTexture(roughnessTexture: vtkTexture): boolean;
 
+  /**
+   * Set the roughness & metallic texture.
+   * @param {vtkTexture} RMTexture
+   */
+  setRMTexture(RMTexture: vtkTexture): boolean;
+
+  /**
+   * Set the occlusion, roughness & metallic texture.
+   * @param {vtkTexture} ORMTexture
+   */
+  setORMTexture(ORMTexture: vtkTexture): boolean;
+
   /**
    * Set the normal texture.
    * @param {vtkTexture} normalTexture

package/Rendering/Core/Property.js

@@ -94,7 +94,9 @@ const DEFAULT_VALUES = {
   lineWidth: 1,
   lighting: true,
   shading: false,
-  materialName: null
+  materialName: null,
+  ORMTexture: null,
+  RMTexture: null
 };
 
 // ----------------------------------------------------------------------------
@@ -105,7 +107,7 @@ function extend(publicAPI, model) {
 
   // Build VTK API
   macro.obj(publicAPI, model);
-  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.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', 'ORMTexture', 'RMTexture']);
   macro.setGetArray(publicAPI, model, ['ambientColor', 'specularColor', 'diffuseColor', 'edgeColor'], 3);
 
   // Object methods

package/Rendering/WebGPU/Buffer.js

@@ -42,13 +42,14 @@ function vtkWebGPUBuffer(publicAPI, model) {
     bufferSubData(model.device.getHandle(), model.handle, 0, data.buffer);
   };
   publicAPI.createAndWrite = (data, usage) => {
+    const paddedSize = Math.ceil(data.byteLength / 4) * 4;
     model.handle = model.device.getHandle().createBuffer({
-      size: data.byteLength,
+      size: paddedSize,
       usage,
       mappedAtCreation: true,
       label: model.label
     });
-    model.sizeInBytes = data.byteLength;
+    model.sizeInBytes = paddedSize;
     model.usage = usage;
     new Uint8Array(model.handle.getMappedRange()).set(new Uint8Array(data.buffer)); // memcpy
     model.handle.unmap();

package/Rendering/WebGPU/CellArrayMapper.js

@@ -595,44 +595,65 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
     const fDesc = pipeline.getShaderDescription('fragment');
     code = fDesc.getCode();
     const actor = model.WebGPUActor.getRenderable();
+    const property = actor.getProperty();
     const checkDims = texture => {
       if (!texture) return false;
       const dims = texture.getDimensionality();
       return dims === numComp;
     };
     const usedTextures = [];
-    if (actor.getProperty().getDiffuseTexture?.()?.getImageLoaded() || actor.getTextures()[0] || model.colorTexture) {
+    const diffuseTexture = property.getDiffuseTexture?.();
+    if (diffuseTexture?.getImageLoaded() || actor.getTextures()[0] || model.colorTexture) {
       if (
       // Chained or statements here are questionable
-      checkDims(actor.getProperty().getDiffuseTexture?.()) || checkDims(actor.getTextures()[0]) || checkDims(model.colorTexture)) {
+      checkDims(diffuseTexture) || checkDims(actor.getTextures()[0]) || checkDims(model.colorTexture)) {
         usedTextures.push('_diffuseMap = textureSample(DiffuseTexture, DiffuseTextureSampler, input.tcoordVS);');
       }
     }
-    if (actor.getProperty().getRoughnessTexture?.()?.getImageLoaded()) {
-      if (checkDims(actor.getProperty().getRoughnessTexture())) {
-        usedTextures.push('_roughnessMap = textureSample(RoughnessTexture, RoughnessTextureSampler, input.tcoordVS);');
+    const ormTexture = property.getORMTexture?.();
+    const rmTexture = property.getRMTexture?.();
+    const roughnessTexture = property.getRoughnessTexture?.();
+    const metallicTexture = property.getMetallicTexture?.();
+    const ambientOcclusionTexture = property.getAmbientOcclusionTexture?.();
+    const emissionTexture = property.getEmissionTexture?.();
+    const normalTexture = property.getNormalTexture?.();
+
+    // ORM texture support: if present, sample R/G/B for AO/Roughness/Metallic
+    if (ormTexture?.getImageLoaded()) {
+      if (checkDims(ormTexture)) {
+        usedTextures.push('_ambientOcclusionMap = textureSample(ORMTexture, ORMTextureSampler, input.tcoordVS).rrra;', '_roughnessMap = textureSample(ORMTexture, ORMTextureSampler, input.tcoordVS).ggga;', '_metallicMap = textureSample(ORMTexture, ORMTextureSampler, input.tcoordVS).bbba;');
       }
-    }
-    if (actor.getProperty().getMetallicTexture?.()?.getImageLoaded()) {
-      if (checkDims(actor.getProperty().getMetallicTexture())) {
-        usedTextures.push('_metallicMap = textureSample(MetallicTexture, MetallicTextureSampler, input.tcoordVS);');
+    } else if (rmTexture?.getImageLoaded()) {
+      if (checkDims(rmTexture)) {
+        usedTextures.push('_roughnessMap = textureSample(RMTexture, RMTextureSampler, input.tcoordVS).ggga;', '_metallicMap = textureSample(RMTexture, RMTextureSampler, input.tcoordVS).bbba;');
       }
-    }
-    if (actor.getProperty().getNormalTexture?.()?.getImageLoaded()) {
-      if (checkDims(actor.getProperty().getNormalTexture())) {
-        usedTextures.push('_normalMap = textureSample(NormalTexture, NormalTextureSampler, input.tcoordVS);');
+    } else {
+      if (roughnessTexture?.getImageLoaded()) {
+        if (checkDims(roughnessTexture)) {
+          usedTextures.push('_roughnessMap = textureSample(RoughnessTexture, RoughnessTextureSampler, input.tcoordVS);');
+        }
       }
-    }
-    if (actor.getProperty().getAmbientOcclusionTexture?.()?.getImageLoaded()) {
-      if (checkDims(actor.getProperty().getAmbientOcclusionTexture())) {
-        usedTextures.push('_ambientOcclusionMap = textureSample(AmbientOcclusionTexture, AmbientOcclusionTextureSampler, input.tcoordVS);');
+      if (metallicTexture?.getImageLoaded()) {
+        if (checkDims(metallicTexture)) {
+          usedTextures.push('_metallicMap = textureSample(MetallicTexture, MetallicTextureSampler, input.tcoordVS);');
+        }
+      }
+      if (ambientOcclusionTexture?.getImageLoaded()) {
+        if (checkDims(ambientOcclusionTexture)) {
+          usedTextures.push('_ambientOcclusionMap = textureSample(AmbientOcclusionTexture, AmbientOcclusionTextureSampler, input.tcoordVS);');
+        }
       }
     }
-    if (actor.getProperty().getEmissionTexture?.()?.getImageLoaded()) {
-      if (checkDims(actor.getProperty().getEmissionTexture())) {
+    if (emissionTexture?.getImageLoaded()) {
+      if (checkDims(emissionTexture)) {
         usedTextures.push('_emissionMap = textureSample(EmissionTexture, EmissionTextureSampler, input.tcoordVS);');
       }
     }
+    if (normalTexture?.getImageLoaded()) {
+      if (checkDims(normalTexture)) {
+        usedTextures.push('_normalMap = textureSample(NormalTexture, NormalTextureSampler, input.tcoordVS);');
+      }
+    }
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::TCoord::Impl', usedTextures).result;
     fDesc.setCode(code);
   };
@@ -863,6 +884,14 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
       const pair = ['Diffuse', model.colorTexture];
       textures.push(pair);
     }
+    if (actor.getProperty().getORMTexture?.()) {
+      const pair = ['ORM', actor.getProperty().getORMTexture()];
+      textures.push(pair);
+    }
+    if (actor.getProperty().getRMTexture?.()) {
+      const pair = ['RM', actor.getProperty().getRMTexture()];
+      textures.push(pair);
+    }
     if (actor.getProperty().getRoughnessTexture?.()) {
       const pair = ['Roughness', actor.getProperty().getRoughnessTexture()];
       textures.push(pair);

package/Rendering/WebGPU/ForwardPass.js

@@ -144,7 +144,7 @@ function vtkForwardPass(publicAPI, model) {
               dstFactor: 'one-minus-src-alpha'
             },
             alpha: {
-              srcfactor: 'one',
+              srcFactor: 'one',
               dstFactor: 'one-minus-src-alpha'
             }
           }

package/Rendering/WebGPU/OrderIndependentTranslucentPass.js

@@ -156,7 +156,7 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
               dstFactor: 'one'
             },
             alpha: {
-              srcfactor: 'one',
+              srcFactor: 'one',
               dstFactor: 'one'
             }
           }
@@ -168,7 +168,7 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
               dstFactor: 'one-minus-src'
             },
             alpha: {
-              srcfactor: 'one',
+              srcFactor: 'one',
               dstFactor: 'one-minus-src-alpha'
             }
           }
@@ -209,7 +209,7 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
               dstFactor: 'one-minus-src-alpha'
             },
             alpha: {
-              srcfactor: 'one',
+              srcFactor: 'one',
               dstFactor: 'one-minus-src-alpha'
             }
           }

package/Rendering/WebGPU/RenderEncoder.js

@@ -190,7 +190,7 @@ function extend(publicAPI, model) {
             dstFactor: 'one-minus-src-alpha'
           },
           alpha: {
-            srcfactor: 'one',
+            srcFactor: 'one',
             dstFactor: 'one-minus-src-alpha'
           }
         }

package/Rendering/WebGPU/VolumePass.js

@@ -424,7 +424,7 @@ function vtkWebGPUVolumePass(publicAPI, model) {
               operation: 'max'
             },
             alpha: {
-              srcfactor: 'one',
+              srcFactor: 'one',
               dstFactor: 'one',
               operation: 'max'
             }
@@ -438,7 +438,7 @@ function vtkWebGPUVolumePass(publicAPI, model) {
               operation: 'min'
             },
             alpha: {
-              srcfactor: 'one',
+              srcFactor: 'one',
               dstFactor: 'one',
               operation: 'min'
             }
@@ -516,7 +516,7 @@ function vtkWebGPUVolumePass(publicAPI, model) {
               dstFactor: 'one-minus-src-alpha'
             },
             alpha: {
-              srcfactor: 'one',
+              srcFactor: 'one',
               dstFactor: 'one-minus-src-alpha'
             }
           }
@@ -549,7 +549,7 @@ function vtkWebGPUVolumePass(publicAPI, model) {
               dstFactor: 'one-minus-src-alpha'
             },
             alpha: {
-              srcfactor: 'one',
+              srcFactor: 'one',
               dstFactor: 'one-minus-src-alpha'
             }
           }
@@ -590,7 +590,7 @@ function vtkWebGPUVolumePass(publicAPI, model) {
               dstFactor: 'one-minus-src-alpha'
             },
             alpha: {
-              srcfactor: 'one',
+              srcFactor: 'one',
               dstFactor: 'one-minus-src-alpha'
             }
           }

package/package.json

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