UNPKG

molstar

Version:

A comprehensive macromolecular library.

441 lines (440 loc) 18.1 kB
/** * Copyright (c) 2018-2025 mol* contributors, licensed under MIT, See LICENSE file for more info. * * @author Alexander Rose <alexander.rose@weirdbyte.de> */ import { ParamDefinition as PD } from '../../mol-util/param-definition'; import { Visual } from '../visual'; import { Volume } from '../../mol-model/volume'; import { Geometry } from '../../mol-geo/geometry/geometry'; import { Theme } from '../../mol-theme/theme'; import { createIdentityTransform } from '../../mol-geo/geometry/transform-data'; import { createRenderObject, getNextMaterialId } from '../../mol-gl/render-object'; import { isEveryLoci, EmptyLoci, isEmptyLoci } from '../../mol-model/loci'; import { Interval, SortedArray } from '../../mol-data/int'; import { getQualityProps, VisualUpdateState } from '../util'; import { ColorTheme } from '../../mol-theme/color'; import { ValueCell } from '../../mol-util'; import { createSizes } from '../../mol-geo/geometry/size-data'; import { createColors } from '../../mol-geo/geometry/color-data'; import { EPSILON, Mat4 } from '../../mol-math/linear-algebra'; import { Representation } from '../representation'; import { BaseGeometry } from '../../mol-geo/geometry/base'; import { Subject } from 'rxjs'; import { Task } from '../../mol-task'; import { isPromiseLike } from '../../mol-util/type-helpers'; import { createMarkers } from '../../mol-geo/geometry/marker-data'; import { SizeTheme } from '../../mol-theme/size'; function createVolumeRenderObject(volume, geometry, locationIt, theme, props, materialId) { const { createValues, createRenderableState } = Geometry.getUtils(geometry); const transform = createIdentityTransform(); const values = createValues(geometry, transform, locationIt, theme, props); const state = createRenderableState(props); return createRenderObject(geometry.kind, values, state, materialId); } export function VolumeVisual(builder, materialId) { const { defaultProps, createGeometry, createLocationIterator, getLoci, eachLocation, setUpdateState, mustRecreate, dispose } = builder; const { updateValues, updateBoundingSphere, updateRenderableState, createPositionIterator } = builder.geometryUtils; const updateState = VisualUpdateState.create(); let renderObject; let newProps; let newTheme; let newVolume; let newKey; let currentProps = Object.assign({}, defaultProps); let currentTheme = 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; VisualUpdateState.reset(updateState); if (!renderObject) { updateState.createNew = true; } else if (!Volume.areEquivalent(newVolume, currentVolume) || newKey !== currentKey) { updateState.createNew = true; } if (updateState.createNew) { updateState.createGeometry = true; return; } setUpdateState(updateState, volume, newProps, currentProps, newTheme, currentTheme); if (!ColorTheme.areEqual(theme.color, currentTheme.color)) { updateState.updateColor = true; } if (!SizeTheme.areEqual(theme.size, currentTheme.size)) { updateState.updateSize = true; } if (newProps.instanceGranularity !== currentProps.instanceGranularity) { updateState.updateTransform = 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.updateTransform) { // console.log('update transform'); locationIt = createLocationIterator(newVolume, newKey); const { instanceCount, groupCount } = locationIt; if (newProps.instanceGranularity) { createMarkers(instanceCount, 'instance', renderObject.values); } else { createMarkers(instanceCount * groupCount, 'groupInstance', renderObject.values); } } else { locationIt.reset(); } if (updateState.createGeometry) { if (newGeometry) { ValueCell.updateIfChanged(renderObject.values.drawCount, Geometry.getDrawCount(newGeometry)); ValueCell.updateIfChanged(renderObject.values.uVertexCount, Geometry.getVertexCount(newGeometry)); ValueCell.updateIfChanged(renderObject.values.uGroupCount, Geometry.getGroupCount(newGeometry)); } 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) { createSizes(locationIt, newTheme.size, renderObject.values); } } if (updateState.updateColor) { 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.Cell.isLoci(loci)) { if (Volume.Cell.isLociEmpty(loci)) return false; if (!Volume.areEquivalent(loci.volume, volume)) return false; if (apply(Interval.ofSingleton(0))) changed = true; } else if (Volume.Segment.isLoci(loci)) { if (Volume.Segment.isLociEmpty(loci)) return false; if (!Volume.areEquivalent(loci.volume, volume)) return false; if (!SortedArray.has(loci.segments, key)) return false; if (apply(Interval.ofSingleton(0))) changed = true; } return changed; } function lociApply(loci, apply) { if (isEveryLoci(loci)) { if (currentProps.instanceGranularity) { return apply(Interval.ofBounds(0, locationIt.instanceCount)); } else { return apply(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 isPromiseLike(newGeometry) ? newGeometry.then(update) : update(newGeometry); } else { update(); } }, getLoci(pickingId) { return renderObject ? getLoci(pickingId, currentVolume, currentKey, currentProps, renderObject.id) : EmptyLoci; }, eachLocation(cb) { locationIt.reset(); while (locationIt.hasNext) { const { location, isSecondary } = locationIt.move(); cb(location, isSecondary); } }, mark(loci, action) { return Visual.mark(renderObject, loci, action, lociApply); }, setVisibility(visible) { Visual.setVisibility(renderObject, visible); }, setAlphaFactor(alphaFactor) { Visual.setAlphaFactor(renderObject, alphaFactor); }, setPickable(pickable) { Visual.setPickable(renderObject, pickable); }, setColorOnly(colorOnly) { Visual.setColorOnly(renderObject, colorOnly); }, setTransform(matrix, instanceMatrices) { Visual.setTransform(renderObject, matrix, instanceMatrices); }, setOverpaint(overpaint) { return Visual.setOverpaint(renderObject, overpaint, lociApply, true); }, setTransparency(transparency) { return Visual.setTransparency(renderObject, transparency, lociApply, true); }, setEmissive(emissive) { return Visual.setEmissive(renderObject, emissive, lociApply, true); }, setSubstance(substance) { return Visual.setSubstance(renderObject, substance, lociApply, true); }, setClipping(clipping) { return Visual.setClipping(renderObject, clipping, lociApply, true); }, setThemeStrength(strength) { Visual.setThemeStrength(renderObject, strength); }, destroy() { dispose === null || dispose === void 0 ? void 0 : dispose(geometry); if (renderObject) { renderObject.state.disposed = true; renderObject = undefined; } }, mustRecreate }; } export function VolumeRepresentationProvider(p) { return p; } // export const VolumeParams = { ...BaseGeometry.Params, }; export function VolumeRepresentation(label, ctx, getParams, visualCtor, getLoci, getKeys = () => [-1]) { let version = 0; const { webgl } = ctx; const updated = new Subject(); const geometryState = new Representation.GeometryState(); const materialId = getNextMaterialId(); const renderObjects = []; const _state = Representation.createState(); const visuals = new Map(); let _volume; let _keys; let _params; let _props; let _theme = Theme.createEmpty(); async function visual(runtime, key) { var _a; let visual = visuals.get(key); if (!visual) { visual = visualCtor(materialId, _volume, key, _props, webgl); visuals.set(key, visual); } else if ((_a = visual.mustRecreate) === null || _a === void 0 ? void 0 : _a.call(visual, { volume: _volume, key }, _props, webgl)) { visual.destroy(); visual = visualCtor(materialId, _volume, key, _props, webgl); visuals.set(key, visual); } return visual.createOrUpdate({ webgl, runtime }, _theme, _props, { volume: _volume, key }); } function createOrUpdate(props = {}, volume) { if (volume && volume !== _volume) { _params = getParams(ctx, volume); _volume = volume; if (!_props) _props = PD.getDefaultValues(_params); } const qualityProps = getQualityProps(Object.assign({}, _props, props), _volume); Object.assign(_props, props, qualityProps); _keys = getKeys(_props); return Task.create('Creating or updating VolumeRepresentation', async (runtime) => { const toDelete = new Set(visuals.keys()); for (let i = 0, il = _keys.length; i < il; ++i) { const segment = _keys[i]; toDelete.delete(segment); const promise = visual(runtime, segment); if (promise) await promise; } toDelete.forEach(segment => { var _a; (_a = visuals.get(segment)) === null || _a === void 0 ? void 0 : _a.destroy(); visuals.delete(segment); }); // update list of renderObjects renderObjects.length = 0; visuals.forEach(visual => { if (visual.renderObject) { renderObjects.push(visual.renderObject); geometryState.add(visual.renderObject.id, visual.geometryVersion); } }); geometryState.snapshot(); // increment version updated.next(version++); }); } function mark(loci, action) { let changed = false; visuals.forEach(visual => { changed = visual.mark(loci, action) || changed; }); return changed; } function setVisualState(visual, state) { if (state.visible !== undefined && visual) visual.setVisibility(state.visible); if (state.alphaFactor !== undefined && visual) visual.setAlphaFactor(state.alphaFactor); if (state.pickable !== undefined && visual) visual.setPickable(state.pickable); if (state.overpaint !== undefined && visual) visual.setOverpaint(state.overpaint); if (state.transparency !== undefined && visual) visual.setTransparency(state.transparency); if (state.emissive !== undefined && visual) visual.setEmissive(state.emissive); if (state.substance !== undefined && visual) visual.setSubstance(state.substance); if (state.clipping !== undefined && visual) visual.setClipping(state.clipping); if (state.transform !== undefined && visual) visual.setTransform(state.transform); if (state.themeStrength !== undefined && visual) visual.setThemeStrength(state.themeStrength); } function setState(state) { const { visible, alphaFactor, pickable, overpaint, transparency, emissive, substance, clipping, transform, themeStrength, syncManually, markerActions } = state; const newState = {}; if (visible !== undefined) newState.visible = visible; if (alphaFactor !== undefined) newState.alphaFactor = alphaFactor; if (pickable !== undefined) newState.pickable = pickable; if (overpaint !== undefined) newState.overpaint = overpaint; if (transparency !== undefined) newState.transparency = transparency; if (emissive !== undefined) newState.emissive = emissive; if (substance !== undefined) newState.substance = substance; if (clipping !== undefined) newState.clipping = clipping; if (themeStrength !== undefined) newState.themeStrength = themeStrength; if (transform !== undefined && !Mat4.areEqual(transform, _state.transform, EPSILON)) { newState.transform = transform; } if (syncManually !== undefined) newState.syncManually = syncManually; if (markerActions !== undefined) newState.markerActions = markerActions; visuals.forEach(visual => setVisualState(visual, newState)); Representation.updateState(_state, state); } function setTheme(theme) { _theme = theme; } function destroy() { visuals.forEach(visual => visual.destroy()); visuals.clear(); } return { label, get groupCount() { let groupCount = 0; visuals.forEach(visual => { if (visual.renderObject) groupCount += visual.groupCount; }); return groupCount; }, get props() { return _props; }, get params() { return _params; }, get state() { return _state; }, get theme() { return _theme; }, get geometryVersion() { return geometryState.version; }, renderObjects, updated, createOrUpdate, setState, setTheme, getLoci: (pickingId) => { let loci = EmptyLoci; visuals.forEach(visual => { const _loci = visual.getLoci(pickingId); if (!isEmptyLoci(_loci)) loci = _loci; }); return loci; }, getAllLoci: () => { return [getLoci(_volume, _props)]; }, eachLocation: (cb) => { visuals.forEach(visual => { visual.eachLocation(cb); }); }, mark, destroy }; }