Prop

Introduction

vtkProp is an abstract superclass for any objects that can exist in a
rendered scene (either 2D or 3D). Instances of vtkProp may respond to
various render methods (e.g., RenderOpaqueGeometry()). vtkProp also
defines the API for picking, LOD manipulation, and common instance
variables that control visibility, picking, and dragging.

newInstance()

visibility

Set/Get visibility of this vtkProp. Initial value is true.

pickable

Set/Get the pickable instance variable. This determines if the vtkProp
can be picked (typically using the mouse). Also see dragable.
Initial value is true.

dragable

Set/Get the value of the dragable instance variable. This determines if
an Prop, once picked, can be dragged (translated) through space.
This is typically done through an interactive mouse interface.
This does not affect methods such as SetPosition, which will continue
to work. It is just intended to prevent some vtkProp’ss from being
dragged from within a user interface.
Initial value is true.

getRedrawMTime()

Return the mtime of anything that would cause the rendered image to
appear differently. Usually this involves checking the mtime of the
prop plus anything else it depends on such as properties, textures
etc.

useBounds

In case the Visibility flag is true, tell if the bounds of this prop
should be taken into account or ignored during the computation of other
bounding boxes, like in vtkRenderer::ResetCamera().
Initial value is true.

Source

index.js
import macro from 'vtk.js/Sources/macro';

function notImplemented(method) {
return () => macro.vtkErrorMacro(`vtkProp::${method} - NOT IMPLEMENTED`);
}

// ----------------------------------------------------------------------------
// vtkProp methods
// ----------------------------------------------------------------------------

function vtkProp(publicAPI, model) {
// Set our className
model.classHierarchy.push('vtkProp');

publicAPI.getMTime = () => {
let m1 = model.mtime;
for (let index = 0; index < model.textures.length; ++index) {
const m2 = model.textures[index].getMTime();
if (m2 > m1) {
m1 = m2;
}
}
return m1;
};

publicAPI.getNestedProps = () => null;
publicAPI.getActors = () => [];
publicAPI.getActors2D = () => [];
publicAPI.getVolumes = () => [];

publicAPI.pick = notImplemented('pick');
publicAPI.hasKey = notImplemented('hasKey');

publicAPI.getRedrawMTime = () => model.mtime;

publicAPI.setEstimatedRenderTime = (t) => {
model.estimatedRenderTime = t;
model.savedEstimatedRenderTime = t;
};

publicAPI.restoreEstimatedRenderTime = () => {
model.estimatedRenderTime = model.savedEstimatedRenderTime;
};

publicAPI.addEstimatedRenderTime = (t) => {
model.estimatedRenderTime += t;
};

publicAPI.setAllocatedRenderTime = (t) => {
model.allocatedRenderTime = t;
model.savedEstimatedRenderTime = model.estimatedRenderTime;
model.estimatedRenderTime = 0;
};

publicAPI.getSupportsSelection = () => false;

publicAPI.getTextures = () => model.textures;
publicAPI.hasTexture = (texture) => model.textures.indexOf(texture) !== -1;
publicAPI.addTexture = (texture) => {
if (texture && !publicAPI.hasTexture(texture)) {
model.textures = model.textures.concat(texture);
publicAPI.modified();
}
};

publicAPI.removeTexture = (texture) => {
const newTextureList = model.textures.filter((item) => item !== texture);
if (model.textures.length !== newTextureList.length) {
model.textures = newTextureList;
publicAPI.modified();
}
};

publicAPI.removeAllTextures = () => {
model.textures = [];
publicAPI.modified();
};
}

// ----------------------------------------------------------------------------
// Object factory
// ----------------------------------------------------------------------------

const DEFAULT_VALUES = {
visibility: true,
pickable: true,
dragable: true,
useBounds: true,
allocatedRenderTime: 10,
estimatedRenderTime: 0,
savedEstimatedRenderTime: 0,
renderTimeMultiplier: 1,
paths: null,
textures: [],
};

// ----------------------------------------------------------------------------

export function extend(publicAPI, model, initialValues = {}) {
Object.assign(model, DEFAULT_VALUES, initialValues);

// Build VTK API
macro.obj(publicAPI, model);
macro.get(publicAPI, model, ['estimatedRenderTime', 'allocatedRenderTime']);
macro.setGet(publicAPI, model, [
'visibility',
'pickable',
'dragable',
'useBounds',
'renderTimeMultiplier',
]);

// Object methods
vtkProp(publicAPI, model);
}

// ----------------------------------------------------------------------------

export const newInstance = macro.newInstance(extend, 'vtkProp');

// ----------------------------------------------------------------------------

export default { newInstance, extend };