molstar
Version:
A comprehensive macromolecular library.
292 lines • 13.1 kB
JavaScript
/**
* Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
*
* @author Alexander Rose <alexander.rose@weirdbyte.de>
*/
import { __assign, __awaiter, __generator } from "tslib";
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 } from '../../mol-model/loci';
import { Interval } 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 { 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';
function createVolumeRenderObject(volume, geometry, locationIt, theme, props, materialId) {
var _a = Geometry.getUtils(geometry), createValues = _a.createValues, createRenderableState = _a.createRenderableState;
var transform = createIdentityTransform();
var values = createValues(geometry, transform, locationIt, theme, props);
var state = createRenderableState(props);
return createRenderObject(geometry.kind, values, state, materialId);
}
export function VolumeVisual(builder, materialId) {
var defaultProps = builder.defaultProps, createGeometry = builder.createGeometry, createLocationIterator = builder.createLocationIterator, getLoci = builder.getLoci, eachLocation = builder.eachLocation, setUpdateState = builder.setUpdateState, mustRecreate = builder.mustRecreate, dispose = builder.dispose;
var _a = builder.geometryUtils, updateValues = _a.updateValues, updateBoundingSphere = _a.updateBoundingSphere, updateRenderableState = _a.updateRenderableState, createPositionIterator = _a.createPositionIterator;
var updateState = VisualUpdateState.create();
var renderObject;
var newProps;
var newTheme;
var newVolume;
var currentProps = Object.assign({}, defaultProps);
var currentTheme = Theme.createEmpty();
var currentVolume;
var geometry;
var locationIt;
var positionIt;
function prepareUpdate(theme, props, volume) {
if (!volume && !currentVolume) {
throw new Error('missing volume');
}
newProps = Object.assign({}, currentProps, props);
newTheme = theme;
newVolume = volume;
VisualUpdateState.reset(updateState);
if (!renderObject) {
updateState.createNew = true;
}
else if (!currentVolume || !Volume.areEquivalent(newVolume, currentVolume)) {
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 (updateState.createGeometry) {
updateState.updateColor = true;
}
}
function update(newGeometry) {
if (updateState.createNew) {
locationIt = createLocationIterator(newVolume);
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');
}
locationIt.reset();
if (updateState.createGeometry) {
if (newGeometry) {
ValueCell.updateIfChanged(renderObject.values.drawCount, Geometry.getDrawCount(newGeometry));
ValueCell.updateIfChanged(renderObject.values.uVertexCount, Geometry.getVertexCount(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;
if (newGeometry)
geometry = newGeometry;
}
function lociApply(loci, apply) {
if (isEveryLoci(loci)) {
return apply(Interval.ofBounds(0, locationIt.groupCount * locationIt.instanceCount));
}
else {
return eachLocation(loci, currentVolume, currentProps, apply);
}
}
return {
get groupCount() { return locationIt ? locationIt.count : 0; },
get renderObject() { return renderObject; },
createOrUpdate: function (ctx, theme, props, volume) {
if (props === void 0) { props = {}; }
return __awaiter(this, void 0, void 0, function () {
var newGeometry;
return __generator(this, function (_a) {
prepareUpdate(theme, props, volume || currentVolume);
if (updateState.createGeometry) {
newGeometry = createGeometry(ctx, newVolume, newTheme, newProps, geometry);
return [2 /*return*/, isPromiseLike(newGeometry) ? newGeometry.then(update) : update(newGeometry)];
}
else {
update();
}
return [2 /*return*/];
});
});
},
getLoci: function (pickingId) {
return renderObject ? getLoci(pickingId, currentVolume, currentProps, renderObject.id) : EmptyLoci;
},
mark: function (loci, action) {
return Visual.mark(renderObject, loci, action, lociApply);
},
setVisibility: function (visible) {
Visual.setVisibility(renderObject, visible);
},
setAlphaFactor: function (alphaFactor) {
Visual.setAlphaFactor(renderObject, alphaFactor);
},
setPickable: function (pickable) {
Visual.setPickable(renderObject, pickable);
},
setColorOnly: function (colorOnly) {
Visual.setColorOnly(renderObject, colorOnly);
},
setTransform: function (matrix, instanceMatrices) {
Visual.setTransform(renderObject, matrix, instanceMatrices);
},
setOverpaint: function (overpaint) {
return Visual.setOverpaint(renderObject, overpaint, lociApply, true);
},
setTransparency: function (transparency) {
return Visual.setTransparency(renderObject, transparency, lociApply, true);
},
setClipping: function (clipping) {
return Visual.setClipping(renderObject, clipping, lociApply, true);
},
destroy: function () {
dispose === null || dispose === void 0 ? void 0 : dispose(geometry);
if (renderObject) {
renderObject.state.disposed = true;
renderObject = undefined;
}
},
mustRecreate: mustRecreate
};
}
export function VolumeRepresentationProvider(p) { return p; }
//
export var VolumeParams = __assign({}, BaseGeometry.Params);
export function VolumeRepresentation(label, ctx, getParams, visualCtor, getLoci) {
var version = 0;
var webgl = ctx.webgl;
var updated = new Subject();
var materialId = getNextMaterialId();
var renderObjects = [];
var _state = Representation.createState();
var visual;
var _volume;
var _params;
var _props;
var _theme = Theme.createEmpty();
function createOrUpdate(props, volume) {
var _this = this;
if (props === void 0) { props = {}; }
if (volume && volume !== _volume) {
_params = getParams(ctx, volume);
_volume = volume;
if (!_props)
_props = PD.getDefaultValues(_params);
}
var qualityProps = getQualityProps(Object.assign({}, _props, props), _volume);
Object.assign(_props, props, qualityProps);
return Task.create('Creating or updating VolumeRepresentation', function (runtime) { return __awaiter(_this, void 0, void 0, function () {
var promise;
var _a;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
if (!visual) {
visual = visualCtor(materialId, _volume, _props, webgl);
}
else if ((_a = visual.mustRecreate) === null || _a === void 0 ? void 0 : _a.call(visual, _volume, _props, webgl)) {
visual.destroy();
visual = visualCtor(materialId, _volume, _props, webgl);
}
promise = visual.createOrUpdate({ webgl: webgl, runtime: runtime }, _theme, _props, volume);
if (!promise) return [3 /*break*/, 2];
return [4 /*yield*/, promise];
case 1:
_b.sent();
_b.label = 2;
case 2:
// update list of renderObjects
renderObjects.length = 0;
if (visual && visual.renderObject)
renderObjects.push(visual.renderObject);
// increment version
updated.next(version++);
return [2 /*return*/];
}
});
}); });
}
function mark(loci, action) {
return visual ? visual.mark(loci, action) : false;
}
function setState(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.transform !== undefined && visual)
visual.setTransform(state.transform);
Representation.updateState(_state, state);
}
function setTheme(theme) {
_theme = theme;
}
function destroy() {
if (visual)
visual.destroy();
}
return {
label: label,
get groupCount() {
return visual ? visual.groupCount : 0;
},
get props() { return _props; },
get params() { return _params; },
get state() { return _state; },
get theme() { return _theme; },
renderObjects: renderObjects,
updated: updated,
createOrUpdate: createOrUpdate,
setState: setState,
setTheme: setTheme,
getLoci: function (pickingId) {
if (pickingId === undefined)
return getLoci(_volume, _props);
return visual ? visual.getLoci(pickingId) : EmptyLoci;
},
mark: mark,
destroy: destroy
};
}
//# sourceMappingURL=representation.js.map