molstar
Version:
A comprehensive macromolecular library.
332 lines (331 loc) • 15.1 kB
JavaScript
;
/**
* Copyright (c) 2018-2026 mol* contributors, licensed under MIT, See LICENSE file for more info.
*
* @author Alexander Rose <alexander.rose@weirdbyte.de>
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.VolumeParams = void 0;
exports.VolumeVisual = VolumeVisual;
const visual_1 = require("../visual.js");
const volume_1 = require("../../mol-model/volume.js");
const geometry_1 = require("../../mol-geo/geometry/geometry.js");
const theme_1 = require("../../mol-theme/theme.js");
const transform_data_1 = require("../../mol-geo/geometry/transform-data.js");
const render_object_1 = require("../../mol-gl/render-object.js");
const loci_1 = require("../../mol-model/loci.js");
const int_1 = require("../../mol-data/int.js");
const util_1 = require("../util.js");
const color_1 = require("../../mol-theme/color.js");
const mol_util_1 = require("../../mol-util/index.js");
const size_data_1 = require("../../mol-geo/geometry/size-data.js");
const color_data_1 = require("../../mol-geo/geometry/color-data.js");
const linear_algebra_1 = require("../../mol-math/linear-algebra.js");
const type_helpers_1 = require("../../mol-util/type-helpers.js");
const marker_data_1 = require("../../mol-geo/geometry/marker-data.js");
const size_1 = require("../../mol-theme/size.js");
const base_1 = require("../../mol-geo/geometry/base.js");
exports.VolumeParams = {
...base_1.BaseGeometry.Params,
};
function createVolumeInstancesTransform(volume, invariantBoundingSphere, cellSize, batchSize, transformData) {
const instanceCount = volume.instances.length;
const transformArray = new Float32Array(instanceCount * 16);
for (let i = 0; i < instanceCount; ++i) {
linear_algebra_1.Mat4.toArray(volume.instances[i].transform, transformArray, i * 16);
}
return (0, transform_data_1.createTransform)(transformArray, instanceCount, invariantBoundingSphere, cellSize, batchSize, transformData);
}
function createVolumeRenderObject(volume, geometry, locationIt, theme, props, materialId) {
const { createValues, createRenderableState } = geometry_1.Geometry.getUtils(geometry);
const transform = locationIt.nonInstanceable
? (0, transform_data_1.createIdentityTransform)()
: createVolumeInstancesTransform(volume, geometry.boundingSphere, props.cellSize, props.batchSize);
const values = createValues(geometry, transform, locationIt, theme, props);
const state = createRenderableState(props);
return (0, render_object_1.createRenderObject)(geometry.kind, values, state, materialId);
}
function VolumeVisual(builder, materialId) {
const { defaultProps, createGeometry, createLocationIterator, getLoci, eachLocation, setUpdateState, initUpdateState, mustRecreate, dispose } = builder;
const { updateValues, updateBoundingSphere, updateRenderableState, createPositionIterator } = builder.geometryUtils;
const updateState = util_1.VisualUpdateState.create();
let renderObject;
let newProps;
let newTheme;
let newVolume;
let newKey;
let currentProps = Object.assign({}, defaultProps);
let currentTheme = theme_1.Theme.createEmpty();
let currentVolume;
let currentKey;
let geometry;
let geometryVersion = -1;
let locationIt;
let positionIt;
function prepareUpdate(theme, props, volume, key) {
if (!volume && !currentVolume) {
throw new Error('missing volume');
}
newProps = Object.assign({}, currentProps, props);
newTheme = theme;
newVolume = volume;
newKey = key;
util_1.VisualUpdateState.reset(updateState);
if (!renderObject) {
updateState.createNew = true;
}
else if (volume_1.Grid.areEquivalent(newVolume.grid, currentVolume.grid) && !volume_1.Volume.areInstanceTransformsEqual(newVolume, currentVolume)) {
updateState.updateTransform = true;
}
else if (!volume_1.Volume.areEquivalent(newVolume, currentVolume) || newKey !== currentKey) {
updateState.createNew = true;
}
if (updateState.createNew) {
initUpdateState === null || initUpdateState === void 0 ? void 0 : initUpdateState(updateState, newVolume, newProps, newTheme);
updateState.createGeometry = true;
return;
}
setUpdateState(updateState, volume, newProps, currentProps, newTheme, currentTheme);
if (!color_1.ColorTheme.areEqual(theme.color, currentTheme.color)) {
updateState.updateColor = true;
}
if (!size_1.SizeTheme.areEqual(theme.size, currentTheme.size)) {
updateState.updateSize = true;
}
if (locationIt.nonInstanceable) {
if (newProps.instanceGranularity !== currentProps.instanceGranularity) {
updateState.updateTransform = true;
}
}
else {
if (newProps.instanceGranularity !== currentProps.instanceGranularity || newProps.cellSize !== currentProps.cellSize || newProps.batchSize !== currentProps.batchSize) {
updateState.updateTransform = true;
}
if (updateState.updateTransform) {
updateState.updateMatrix = true;
}
}
if (updateState.updateSize && !('uSize' in renderObject.values)) {
updateState.createGeometry = true;
}
if (updateState.createGeometry) {
updateState.updateColor = true;
updateState.updateSize = true;
}
}
function update(newGeometry) {
if (updateState.createNew) {
locationIt = createLocationIterator(newVolume, newKey);
if (newGeometry) {
renderObject = createVolumeRenderObject(newVolume, newGeometry, locationIt, newTheme, newProps, materialId);
positionIt = createPositionIterator(newGeometry, renderObject.values);
}
else {
throw new Error('expected geometry to be given');
}
}
else {
if (!renderObject) {
throw new Error('expected renderObject to be available');
}
if (updateState.updateColor || updateState.updateSize || updateState.updateTransform || updateState.updateLocation) {
// console.log('update locationIterator');
locationIt = createLocationIterator(newVolume, newKey);
}
if (updateState.updateTransform || updateState.updateLocation) {
// console.log('update transform');
const { instanceCount, groupCount } = locationIt;
if (newProps.instanceGranularity) {
(0, marker_data_1.createMarkers)(instanceCount, 'instance', renderObject.values);
}
else {
(0, marker_data_1.createMarkers)(instanceCount * groupCount, 'groupInstance', renderObject.values);
}
}
if (updateState.updateMatrix) {
// console.log('update matrix');
createVolumeInstancesTransform(newVolume, geometry.boundingSphere, newProps.cellSize, newProps.batchSize, renderObject.values);
}
if (updateState.createGeometry) {
if (newGeometry) {
mol_util_1.ValueCell.updateIfChanged(renderObject.values.drawCount, geometry_1.Geometry.getDrawCount(newGeometry));
mol_util_1.ValueCell.updateIfChanged(renderObject.values.uVertexCount, geometry_1.Geometry.getVertexCount(newGeometry));
mol_util_1.ValueCell.updateIfChanged(renderObject.values.uGroupCount, locationIt.groupCount);
}
else {
throw new Error('expected geometry to be given');
}
}
if (updateState.updateTransform || updateState.createGeometry) {
updateBoundingSphere(renderObject.values, newGeometry || geometry);
positionIt = createPositionIterator(newGeometry || geometry, renderObject.values);
}
if (updateState.updateSize) {
// not all geometries have size data, so check here
if ('uSize' in renderObject.values) {
// console.log('update size');
(0, size_data_1.createSizes)(locationIt, positionIt, newTheme.size, renderObject.values);
}
}
if (updateState.updateColor) {
// console.log('update color');
(0, color_data_1.createColors)(locationIt, positionIt, newTheme.color, renderObject.values);
}
updateValues(renderObject.values, newProps);
updateRenderableState(renderObject.state, newProps);
}
currentProps = newProps;
currentTheme = newTheme;
currentVolume = newVolume;
currentKey = newKey;
if (newGeometry) {
geometry = newGeometry;
geometryVersion += 1;
}
}
function eachInstance(loci, volume, key, apply) {
let changed = false;
if (volume_1.Volume.Cell.isLoci(loci)) {
if (volume_1.Volume.Cell.isLociEmpty(loci))
return false;
if (!volume_1.Volume.areEquivalent(loci.volume, volume))
return false;
for (const { instances } of loci.elements) {
int_1.OrderedSet.forEach(instances, j => {
if (apply(int_1.Interval.ofSingleton(j)))
changed = true;
});
}
}
else if (volume_1.Volume.Segment.isLoci(loci)) {
if (volume_1.Volume.Segment.isLociEmpty(loci))
return false;
if (!volume_1.Volume.areEquivalent(loci.volume, volume))
return false;
for (const { segments, instances } of loci.elements) {
if (int_1.OrderedSet.has(segments, key)) {
int_1.OrderedSet.forEach(instances, j => {
if (apply(int_1.Interval.ofSingleton(j)))
changed = true;
});
}
}
}
else if (volume_1.Volume.Isosurface.isLoci(loci)) {
if (volume_1.Volume.Isosurface.isLociEmpty(loci))
return false;
if (int_1.Interval.is(loci.instances)) {
if (apply(loci.instances))
changed = true;
}
else {
for (let i = 0, il = loci.instances.length; i < il; ++i) {
if (apply(int_1.Interval.ofSingleton(i)))
changed = true;
}
}
}
else if (volume_1.Volume.isLoci(loci)) {
if (volume_1.Volume.isLociEmpty(loci))
return false;
if (int_1.Interval.is(loci.instances)) {
if (apply(loci.instances))
changed = true;
}
else {
for (let i = 0, il = loci.instances.length; i < il; ++i) {
if (apply(int_1.Interval.ofSingleton(i)))
changed = true;
}
}
}
return changed;
}
function lociApply(loci, apply) {
if ((0, loci_1.isEveryLoci)(loci)) {
if (currentProps.instanceGranularity) {
return apply(int_1.Interval.ofBounds(0, locationIt.instanceCount));
}
else {
return apply(int_1.Interval.ofBounds(0, locationIt.groupCount * locationIt.instanceCount));
}
}
else {
if (currentProps.instanceGranularity) {
return eachInstance(loci, currentVolume, currentKey, apply);
}
else {
return eachLocation(loci, currentVolume, currentKey, currentProps, apply);
}
}
}
return {
get groupCount() { return locationIt ? locationIt.count : 0; },
get renderObject() { return renderObject; },
get geometryVersion() { return geometryVersion; },
async createOrUpdate(ctx, theme, props = {}, volumeKey) {
prepareUpdate(theme, props, (volumeKey === null || volumeKey === void 0 ? void 0 : volumeKey.volume) || currentVolume, (volumeKey === null || volumeKey === void 0 ? void 0 : volumeKey.key) || currentKey);
if (updateState.createGeometry) {
const newGeometry = createGeometry(ctx, newVolume, newKey, newTheme, newProps, geometry);
return (0, type_helpers_1.isPromiseLike)(newGeometry) ? newGeometry.then(update) : update(newGeometry);
}
else {
update();
}
},
getLoci(pickingId) {
return renderObject ? getLoci(pickingId, currentVolume, currentKey, currentProps, renderObject.id) : loci_1.EmptyLoci;
},
eachLocation(cb) {
locationIt.reset();
while (locationIt.hasNext) {
const { location, isSecondary } = locationIt.move();
cb(location, isSecondary);
}
},
mark(loci, action) {
return visual_1.Visual.mark(renderObject, loci, action, lociApply);
},
setVisibility(visible) {
visual_1.Visual.setVisibility(renderObject, visible);
},
setAlphaFactor(alphaFactor) {
visual_1.Visual.setAlphaFactor(renderObject, alphaFactor);
},
setPickable(pickable) {
visual_1.Visual.setPickable(renderObject, pickable);
},
setColorOnly(colorOnly) {
visual_1.Visual.setColorOnly(renderObject, colorOnly);
},
setTransform(matrix, instanceMatrices) {
visual_1.Visual.setTransform(renderObject, matrix, instanceMatrices);
},
setOverpaint(overpaint) {
return visual_1.Visual.setOverpaint(renderObject, overpaint, lociApply, true);
},
setTransparency(transparency) {
return visual_1.Visual.setTransparency(renderObject, transparency, lociApply, true);
},
setEmissive(emissive) {
return visual_1.Visual.setEmissive(renderObject, emissive, lociApply, true);
},
setSubstance(substance) {
return visual_1.Visual.setSubstance(renderObject, substance, lociApply, true);
},
setClipping(clipping) {
return visual_1.Visual.setClipping(renderObject, clipping, lociApply, true);
},
setThemeStrength(strength) {
visual_1.Visual.setThemeStrength(renderObject, strength);
},
destroy() {
dispose === null || dispose === void 0 ? void 0 : dispose(geometry);
if (renderObject) {
renderObject.state.disposed = true;
renderObject = undefined;
}
},
mustRecreate
};
}