@kitware/vtk.js 24.0.1 → 24.1.0

package/Rendering/OpenGL/Glyph3DMapper.js

@@ -331,9 +331,10 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
       if (cabo.getElementCount()) {
         // are we drawing edges
         model.drawingEdges = drawSurfaceWithEdges && (i === model.primTypes.TrisEdges || i === model.primTypes.TriStripsEdges);
-        publicAPI.updateShaders(model.primitives[i], ren, actor);
+        model.lastBoundBO = model.primitives[i];
+        model.primitives[i].updateShaders(ren, actor, publicAPI);
         var program = model.primitives[i].getProgram();
-        var mode = publicAPI.getOpenGLMode(representation, i);
+        var mode = model.primitives[i].getOpenGLMode(representation);
         var normalMatrixUsed = program.isUniformUsed('normalMatrix');
         var mcvcMatrixUsed = program.isUniformUsed('MCVCMatrix');
 
@@ -413,6 +414,14 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
     return superClass.getNeedToRebuildBufferObjects(ren, actor);
   };
 
+  publicAPI.getNeedToRebuildShaders = function (cellBO, ren, actor) {
+    if (superClass.getNeedToRebuildShaders(cellBO, ren, actor) || cellBO.getShaderSourceTime().getMTime() < model.renderable.getMTime() || cellBO.getShaderSourceTime().getMTime() < model.currentInput.getMTime()) {
+      return true;
+    }
+
+    return false;
+  };
+
   publicAPI.buildBufferObjects = function (ren, actor) {
     if (model.hardwareSupport) {
       // update the buffer objects if needed

package/Rendering/OpenGL/HardwareSelector.js

@@ -239,7 +239,7 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
 
 
   publicAPI.beginSelection = function () {
-    model._openGLRenderer = model._openGLRenderWindow.getViewNodeFor(model.renderer);
+    model._openGLRenderer = model._openGLRenderWindow.getViewNodeFor(model._renderer);
     model.maxAttributeId = 0;
 
     var size = model._openGLRenderWindow.getSize();
@@ -307,7 +307,7 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
           switch (_context.prev = _context.next) {
             case 0:
               // assign the renderer
-              model.renderer = renderer; // set area to all if no arguments provided
+              model._renderer = renderer; // set area to all if no arguments provided
 
               if (fx1 === undefined) {
                 size = model._openGLRenderWindow.getSize();
@@ -361,12 +361,12 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
 
 
   publicAPI.captureBuffers = function () {
-    if (!model.renderer || !model._openGLRenderWindow) {
+    if (!model._renderer || !model._openGLRenderWindow) {
       vtkErrorMacro('Renderer and view must be set before calling Select.');
       return false;
     }
 
-    model._openGLRenderer = model._openGLRenderWindow.getViewNodeFor(model.renderer); // todo revisit making selection part of core
+    model._openGLRenderer = model._openGLRenderWindow.getViewNodeFor(model._renderer); // todo revisit making selection part of core
     // then we can do this in core
 
     model._openGLRenderWindow.getRenderable().preRender(); // int rgba[4];
@@ -383,8 +383,9 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
     }); // Initialize renderer for selection.
     // change the renderer's background to black, which will indicate a miss
 
-    model.originalBackground = model.renderer.getBackgroundByReference();
-    model.renderer.setBackground(0.0, 0.0, 0.0);
+    model.originalBackground = model._renderer.getBackgroundByReference();
+
+    model._renderer.setBackground(0.0, 0.0, 0.0);
 
     var rpasses = model._openGLRenderWindow.getRenderPasses();
 
@@ -409,7 +410,8 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
 
     publicAPI.endSelection(); // restore original background
 
-    model.renderer.setBackground(model.originalBackground);
+    model._renderer.setBackground(model.originalBackground);
+
     publicAPI.invokeEvent({
       type: 'EndEvent'
     }); // restore image, not needed?
@@ -656,13 +658,13 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
       }
     }
 
-    return convertSelection(model.fieldAssociation, dataMap, model.captureZValues, model.renderer, model._openGLRenderWindow);
+    return convertSelection(model.fieldAssociation, dataMap, model.captureZValues, model._renderer, model._openGLRenderWindow);
   }; //----------------------------------------------------------------------------
 
 
   publicAPI.attach = function (w, r) {
     model._openGLRenderWindow = w;
-    model.renderer = r;
+    model._renderer = r;
   }; // override
 
 

package/Rendering/OpenGL/Helper.js

@@ -2,7 +2,18 @@ import macro from '../../macros.js';
 import vtkCellArrayBufferObject from './CellArrayBufferObject.js';
 import vtkShaderProgram from './ShaderProgram.js';
 import vtkVertexArrayObject from './VertexArrayObject.js';
+import { Representation } from '../Core/Property/Constants.js';
 
+var primTypes = {
+  Start: 0,
+  Points: 0,
+  Lines: 1,
+  Tris: 2,
+  TriStrips: 3,
+  TrisEdges: 4,
+  TriStripsEdges: 5,
+  End: 6
+}; // ----------------------------------------------------------------------------
 // vtkOpenGLHelper methods
 // ----------------------------------------------------------------------------
 
@@ -11,7 +22,8 @@ function vtkOpenGLHelper(publicAPI, model) {
   model.classHierarchy.push('vtkOpenGLHelper');
 
   publicAPI.setOpenGLRenderWindow = function (win) {
-    model.program.setContext(win.getContext());
+    model.context = win.getContext();
+    model.program.setContext(model.context);
     model.VAO.setOpenGLRenderWindow(win);
     model.CABO.setOpenGLRenderWindow(win);
   };
@@ -21,12 +33,141 @@ function vtkOpenGLHelper(publicAPI, model) {
     model.CABO.releaseGraphicsResources();
     model.CABO.setElementCount(0);
   };
+
+  publicAPI.drawArrays = function (ren, actor, rep, oglMapper) {
+    // Are there any entries
+    if (model.CABO.getElementCount()) {
+      // are we drawing edges
+      var mode = publicAPI.getOpenGLMode(rep);
+      var wideLines = publicAPI.haveWideLines(ren, actor);
+      var gl = model.context;
+      var drawingLines = mode === gl.LINES;
+
+      if (drawingLines && wideLines) {
+        publicAPI.updateShaders(ren, actor, oglMapper);
+        gl.drawArraysInstanced(mode, 0, model.CABO.getElementCount(), 2 * Math.ceil(actor.getProperty().getLineWidth()));
+      } else {
+        gl.lineWidth(actor.getProperty().getLineWidth());
+        publicAPI.updateShaders(ren, actor, oglMapper);
+        gl.drawArrays(mode, 0, model.CABO.getElementCount()); // reset the line width
+
+        gl.lineWidth(1);
+      }
+
+      var stride = (mode === gl.POINTS ? 1 : 0) || (mode === gl.LINES ? 2 : 3);
+      return model.CABO.getElementCount() / stride;
+    }
+
+    return 0;
+  };
+
+  publicAPI.getOpenGLMode = function (rep) {
+    var type = model.primitiveType;
+
+    if (rep === Representation.POINTS || type === primTypes.Points) {
+      return model.context.POINTS;
+    }
+
+    if (rep === Representation.WIREFRAME || type === primTypes.Lines || type === primTypes.TrisEdges || type === primTypes.TriStripsEdges) {
+      return model.context.LINES;
+    }
+
+    return model.context.TRIANGLES;
+  };
+
+  publicAPI.haveWideLines = function (ren, actor) {
+    if (actor.getProperty().getLineWidth() > 1.0) {
+      // we have wide lines, but the OpenGL implementation may
+      // actually support them, check the range to see if we
+      // really need have to implement our own wide lines
+      if (model.CABO.getOpenGLRenderWindow()) {
+        if (model.CABO.getOpenGLRenderWindow().getHardwareMaximumLineWidth() >= actor.getProperty().getLineWidth()) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    return false;
+  };
+
+  publicAPI.getNeedToRebuildShaders = function (ren, actor, oglMapper) {
+    // has something changed that would require us to recreate the shader?
+    // candidates are
+    // property modified (representation interpolation and lighting)
+    // input modified
+    // mapper modified (lighting complexity)
+    if (oglMapper.getNeedToRebuildShaders(publicAPI, ren, actor) || publicAPI.getProgram() === 0 || publicAPI.getShaderSourceTime().getMTime() < oglMapper.getMTime() || publicAPI.getShaderSourceTime().getMTime() < actor.getMTime()) {
+      return true;
+    }
+
+    return false;
+  };
+
+  publicAPI.updateShaders = function (ren, actor, oglMapper) {
+    // has something changed that would require us to recreate the shader?
+    if (publicAPI.getNeedToRebuildShaders(ren, actor, oglMapper)) {
+      var shaders = {
+        Vertex: null,
+        Fragment: null,
+        Geometry: null
+      };
+      oglMapper.buildShaders(shaders, ren, actor); // compile and bind the program if needed
+
+      var newShader = model.CABO.getOpenGLRenderWindow().getShaderCache().readyShaderProgramArray(shaders.Vertex, shaders.Fragment, shaders.Geometry); // if the shader changed reinitialize the VAO
+
+      if (newShader !== publicAPI.getProgram()) {
+        publicAPI.setProgram(newShader); // reset the VAO as the shader has changed
+
+        publicAPI.getVAO().releaseGraphicsResources();
+      }
+
+      publicAPI.getShaderSourceTime().modified();
+    } else {
+      model.CABO.getOpenGLRenderWindow().getShaderCache().readyShaderProgram(publicAPI.getProgram());
+    }
+
+    publicAPI.getVAO().bind();
+    oglMapper.setMapperShaderParameters(publicAPI, ren, actor);
+    oglMapper.setPropertyShaderParameters(publicAPI, ren, actor);
+    oglMapper.setCameraShaderParameters(publicAPI, ren, actor);
+    oglMapper.setLightingShaderParameters(publicAPI, ren, actor);
+    oglMapper.invokeShaderCallbacks(publicAPI, ren, actor);
+  };
+
+  publicAPI.setMapperShaderParameters = function (ren, actor, size) {
+    if (publicAPI.haveWideLines(ren, actor)) {
+      publicAPI.getProgram().setUniform2f('viewportSize', size.usize, size.vsize);
+      var lineWidth = parseFloat(actor.getProperty().getLineWidth());
+      var halfLineWidth = lineWidth / 2.0;
+      publicAPI.getProgram().setUniformf('lineWidthStepSize', lineWidth / Math.ceil(lineWidth));
+      publicAPI.getProgram().setUniformf('halfLineWidth', halfLineWidth);
+    }
+  };
+
+  publicAPI.replaceShaderPositionVC = function (shaders, ren, actor) {
+    var VSSource = shaders.Vertex; // for lines, make sure we add the width code
+
+    if (publicAPI.getOpenGLMode(actor.getProperty().getRepresentation()) === model.context.LINES && publicAPI.haveWideLines(ren, actor)) {
+      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Dec', ['//VTK::PositionVC::Dec', 'uniform vec2 viewportSize;', 'uniform float lineWidthStepSize;', 'uniform float halfLineWidth;']).result;
+      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Impl', ['//VTK::PositionVC::Impl', ' if (halfLineWidth > 0.0)', '   {', '   float offset = float(gl_InstanceID / 2) * lineWidthStepSize - halfLineWidth;', '   vec4 tmpPos = gl_Position;', '   vec3 tmpPos2 = tmpPos.xyz / tmpPos.w;', '   tmpPos2.x = tmpPos2.x + 2.0 * mod(float(gl_InstanceID), 2.0) * offset / viewportSize[0];', '   tmpPos2.y = tmpPos2.y + 2.0 * mod(float(gl_InstanceID + 1), 2.0) * offset / viewportSize[1];', '   gl_Position = vec4(tmpPos2.xyz * tmpPos.w, tmpPos.w);', '   }']).result;
+    } // for points make sure to add in the point size
+
+
+    if (actor.getProperty().getRepresentation() === Representation.POINTS || model.primitiveType === primTypes.Points) {
+      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Impl', ['//VTK::PositionVC::Impl', "  gl_PointSize = ".concat(actor.getProperty().getPointSize(), ".0;")], false).result;
+    }
+
+    shaders.Vertex = VSSource;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
 
 var DEFAULT_VALUES = {
+  context: null,
   program: null,
   shaderSourceTime: null,
   VAO: null,
@@ -56,7 +197,8 @@ var newInstance = macro.newInstance(extend); // --------------------------------
 
 var vtkHelper = {
   newInstance: newInstance,
-  extend: extend
+  extend: extend,
+  primTypes: primTypes
 };
 
-export { vtkHelper as default, extend, newInstance };
+export { vtkHelper as default, extend, newInstance, primTypes };

package/Rendering/OpenGL/OrderIndependentTranslucentPass.js

@@ -112,26 +112,18 @@ function vtkOpenGLOrderIndependentTranslucentPass(publicAPI, model) {
     }
 
     var size = viewNode.getSize();
-    var gl = viewNode.getContext();
-
-    if (gl === null) {
-      // nothing to do -> no render context
-      // traverse delegate passes -> has to be done in order for the vtk render-pipeline to work correctly
-      model.delegates.forEach(function (val) {
-        val.traverse(viewNode, publicAPI);
-      });
-      return;
-    } // if we lack the webgl2 and half floatsupport just do
+    var gl = viewNode.getContext(); // if we lack the webgl2 and half floatsupport just do
     // basic alpha blending
 
+    model._supported = false;
 
-    if (!viewNode.getWebgl2() || !gl.getExtension('EXT_color_buffer_half_float') && !gl.getExtension('EXT_color_buffer_float')) {
-      console.log('fallback');
+    if (!gl || !viewNode.getWebgl2() || !gl.getExtension('EXT_color_buffer_half_float') && !gl.getExtension('EXT_color_buffer_float')) {
       publicAPI.setCurrentOperation('translucentPass');
       renNode.traverse(publicAPI);
       return;
-    } // prepare framebuffer // allocate framebuffer if needed and bind it
+    }
 
+    model._supported = true; // prepare framebuffer // allocate framebuffer if needed and bind it
 
     if (model.framebuffer === null) {
       publicAPI.createFramebuffer(viewNode);
@@ -216,7 +208,11 @@ function vtkOpenGLOrderIndependentTranslucentPass(publicAPI, model) {
   };
 
   publicAPI.getShaderReplacement = function () {
-    return translucentShaderReplacement;
+    if (model._supported) {
+      return translucentShaderReplacement;
+    }
+
+    return {};
   };
 
   publicAPI.releaseGraphicsResources = function (viewNode) {

package/Rendering/OpenGL/PolyDataMapper.js

@@ -15,16 +15,7 @@ import { registerOverride } from './ViewNodeFactory.js';
 
 /* eslint-disable no-lonely-if */
 
-var primTypes = {
-  Start: 0,
-  Points: 0,
-  Lines: 1,
-  Tris: 2,
-  TriStrips: 3,
-  TrisEdges: 4,
-  TriStripsEdges: 5,
-  End: 6
-};
+var primTypes = vtkHelper.primTypes;
 var Representation = vtkProperty.Representation,
     Shading = vtkProperty.Shading;
 var ScalarMode = vtkMapper.ScalarMode;
@@ -326,7 +317,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
           FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Normal::Dec', ['uniform mat3 normalMatrix;', 'uniform samplerBuffer textureN;']).result;
           FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Normal::Impl', ['vec3 normalVCVSOutput = normalize(normalMatrix *', '    texelFetchBuffer(textureN, gl_PrimitiveID + PrimitiveIDOffset).xyz);', '  if (gl_FrontFacing == false) { normalVCVSOutput = -normalVCVSOutput; }']).result;
         } else {
-          if (publicAPI.getOpenGLMode(actor.getProperty().getRepresentation(), model.lastBoundBO.getPrimitiveType()) === model.context.LINES) {
+          if (model.lastBoundBO.getOpenGLMode(actor.getProperty().getRepresentation()) === model.context.LINES) {
             // generate a normal for lines, it will be perpendicular to the line
             // and maximally aligned with the camera view direction
             // no clue if this is the best way to do this.
@@ -361,14 +352,11 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
   };
 
   publicAPI.replaceShaderPositionVC = function (shaders, ren, actor) {
+    // replace common shader code
+    model.lastBoundBO.replaceShaderPositionVC(shaders, ren, actor);
     var VSSource = shaders.Vertex;
     var GSSource = shaders.Geometry;
-    var FSSource = shaders.Fragment; // for points make sure to add in the point size
-
-    if (actor.getProperty().getRepresentation() === Representation.POINTS || model.lastBoundBO.getPrimitiveType() === primTypes.Points) {
-      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Impl', ['//VTK::PositionVC::Impl', "  gl_PointSize = ".concat(actor.getProperty().getPointSize(), ".0;")], false).result;
-    } // do we need the vertex in the shader in View Coordinates
-
+    var FSSource = shaders.Fragment; // do we need the vertex in the shader in View Coordinates
 
     var lastLightComplexity = model.lastBoundBO.getReferenceByName('lastLightComplexity');
 
@@ -556,7 +544,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
     var cellNormals = poly.getCellData().getNormals();
     var flat = actor.getProperty().getInterpolation() === Shading.FLAT;
     var representation = actor.getProperty().getRepresentation();
-    var mode = publicAPI.getOpenGLMode(representation, primType); // 1) all surfaces need lighting
+    var mode = cellBO.getOpenGLMode(representation, primType); // 1) all surfaces need lighting
 
     if (mode === model.context.TRIANGLES) {
       needLighting = true; // 2) all cell normals without point normals need lighting
@@ -628,7 +616,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
     // light complexity changed
 
 
-    if (model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || cellBO.getProgram() === 0 || cellBO.getShaderSourceTime().getMTime() < publicAPI.getMTime() || cellBO.getShaderSourceTime().getMTime() < actor.getMTime() || cellBO.getShaderSourceTime().getMTime() < model.renderable.getMTime() || cellBO.getShaderSourceTime().getMTime() < model.currentInput.getMTime() || needRebuild) {
+    if (model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || cellBO.getShaderSourceTime().getMTime() < model.renderable.getMTime() || cellBO.getShaderSourceTime().getMTime() < model.currentInput.getMTime() || needRebuild) {
       model.lastHaveSeenDepthRequest = model.haveSeenDepthRequest;
       return true;
     }
@@ -636,36 +624,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
     return false;
   };
 
-  publicAPI.updateShaders = function (cellBO, ren, actor) {
-    model.lastBoundBO = cellBO; // has something changed that would require us to recreate the shader?
-
-    if (publicAPI.getNeedToRebuildShaders(cellBO, ren, actor)) {
-      var shaders = {
-        Vertex: null,
-        Fragment: null,
-        Geometry: null
-      };
-      publicAPI.buildShaders(shaders, ren, actor); // compile and bind the program if needed
-
-      var newShader = model._openGLRenderWindow.getShaderCache().readyShaderProgramArray(shaders.Vertex, shaders.Fragment, shaders.Geometry); // if the shader changed reinitialize the VAO
-
-
-      if (newShader !== cellBO.getProgram()) {
-        cellBO.setProgram(newShader); // reset the VAO as the shader has changed
-
-        cellBO.getVAO().releaseGraphicsResources();
-      }
-
-      cellBO.getShaderSourceTime().modified();
-    } else {
-      model._openGLRenderWindow.getShaderCache().readyShaderProgram(cellBO.getProgram());
-    }
-
-    cellBO.getVAO().bind();
-    publicAPI.setMapperShaderParameters(cellBO, ren, actor);
-    publicAPI.setPropertyShaderParameters(cellBO, ren, actor);
-    publicAPI.setCameraShaderParameters(cellBO, ren, actor);
-    publicAPI.setLightingShaderParameters(cellBO, ren, actor);
+  publicAPI.invokeShaderCallbacks = function (cellBO, ren, actor) {
     var listCallbacks = model.renderable.getViewSpecificProperties().ShadersCallbacks;
 
     if (listCallbacks) {
@@ -783,8 +742,10 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
       if (cellBO.getProgram().isUniformUsed('cfactor')) {
         cellBO.getProgram().setUniformf('cfactor', cp.factor);
       }
-    }
+    } // handle wide lines
+
 
+    cellBO.setMapperShaderParameters(ren, actor, model.openGLRenderer.getTiledSizeAndOrigin());
     var selector = model.openGLRenderer.getSelector();
     cellBO.getProgram().setUniform3fArray('mapperIndex', selector ? selector.getPropColorValue() : [0.0, 0.0, 0.0]);
     cellBO.getProgram().setUniformi('picking', selector ? selector.getCurrentPass() + 1 : 0);
@@ -997,9 +958,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
 
   publicAPI.renderPieceDraw = function (ren, actor) {
     var representation = actor.getProperty().getRepresentation();
-    var gl = model.context;
-    var drawSurfaceWithEdges = actor.getProperty().getEdgeVisibility() && representation === Representation.SURFACE;
-    gl.lineWidth(actor.getProperty().getLineWidth()); // for every primitive type
+    var drawSurfaceWithEdges = actor.getProperty().getEdgeVisibility() && representation === Representation.SURFACE; // for every primitive type
 
     for (var i = primTypes.Start; i < primTypes.End; i++) {
       // if there are entries
@@ -1008,32 +967,13 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
       if (cabo.getElementCount()) {
         // are we drawing edges
         model.drawingEdges = drawSurfaceWithEdges && (i === primTypes.TrisEdges || i === primTypes.TriStripsEdges);
-        var mode = publicAPI.getOpenGLMode(representation, i);
 
         if (!model.drawingEdges || !model.renderDepth) {
-          publicAPI.updateShaders(model.primitives[i], ren, actor);
-          gl.drawArrays(mode, 0, cabo.getElementCount());
+          model.lastBoundBO = model.primitives[i];
+          model.primitiveIDOffset += model.primitives[i].drawArrays(ren, actor, representation, publicAPI);
         }
-
-        var stride = (mode === gl.POINTS ? 1 : 0) || (mode === gl.LINES ? 2 : 3);
-        model.primitiveIDOffset += cabo.getElementCount() / stride;
       }
-    } // reset the line width
-
-
-    gl.lineWidth(1);
-  };
-
-  publicAPI.getOpenGLMode = function (rep, type) {
-    if (rep === Representation.POINTS || type === primTypes.Points) {
-      return model.context.POINTS;
     }
-
-    if (rep === Representation.WIREFRAME || type === primTypes.Lines || type === primTypes.TrisEdges || type === primTypes.TriStripsEdges) {
-      return model.context.LINES;
-    }
-
-    return model.context.TRIANGLES;
   };
 
   publicAPI.renderPieceFinish = function (ren, actor) {
@@ -1299,10 +1239,9 @@ var newInstance = newInstance$1(extend, 'vtkOpenGLPolyDataMapper'); // ---------
 
 var vtkOpenGLPolyDataMapper$1 = {
   newInstance: newInstance,
-  extend: extend,
-  primTypes: primTypes
+  extend: extend
 }; // Register ourself to OpenGL backend if imported
 
 registerOverride('vtkMapper', newInstance);
 
-export { vtkOpenGLPolyDataMapper$1 as default, extend, newInstance, primTypes };
+export { vtkOpenGLPolyDataMapper$1 as default, extend, newInstance };