molstar 3.0.1 → 3.0.2

package/lib/commonjs/extensions/geo-export/render-object-exporter.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Sukolsak Sakshuwong <sukolsak@stanford.edu>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=render-object-exporter.js.map

package/lib/commonjs/extensions/geo-export/stl-exporter.js

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Sukolsak Sakshuwong <sukolsak@stanford.edu>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StlExporter = void 0;
+var tslib_1 = require("tslib");
+var ascii_1 = require("../../mol-io/common/ascii");
+var linear_algebra_1 = require("../../mol-math/linear-algebra");
+var version_1 = require("../../mol-plugin/version");
+var mesh_exporter_1 = require("./mesh-exporter");
+// avoiding namespace lookup improved performance in Chrome (Aug 2020)
+var v3fromArray = linear_algebra_1.Vec3.fromArray;
+var v3transformMat4 = linear_algebra_1.Vec3.transformMat4;
+var v3triangleNormal = linear_algebra_1.Vec3.triangleNormal;
+var v3toArray = linear_algebra_1.Vec3.toArray;
+var StlExporter = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(StlExporter, _super);
+    function StlExporter(boundingBox) {
+        var _this = _super.call(this) || this;
+        _this.fileExtension = 'stl';
+        _this.triangleBuffers = [];
+        _this.triangleCount = 0;
+        var tmpV = (0, linear_algebra_1.Vec3)();
+        linear_algebra_1.Vec3.add(tmpV, boundingBox.min, boundingBox.max);
+        linear_algebra_1.Vec3.scale(tmpV, tmpV, -0.5);
+        _this.centerTransform = linear_algebra_1.Mat4.fromTranslation((0, linear_algebra_1.Mat4)(), tmpV);
+        return _this;
+    }
+    StlExporter.prototype.addMeshWithColors = function (input) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var values, isGeoTexture, ctx, t, tmpV, v1, v2, v3, stride, aTransform, instanceCount, instanceIndex, _a, vertices, indices, vertexCount, drawCount, vertexArray, i, triangleBuffer, dataView, i, byteOffset;
+            return (0, tslib_1.__generator)(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        values = input.values, isGeoTexture = input.isGeoTexture, ctx = input.ctx;
+                        t = (0, linear_algebra_1.Mat4)();
+                        tmpV = (0, linear_algebra_1.Vec3)();
+                        v1 = (0, linear_algebra_1.Vec3)();
+                        v2 = (0, linear_algebra_1.Vec3)();
+                        v3 = (0, linear_algebra_1.Vec3)();
+                        stride = isGeoTexture ? 4 : 3;
+                        aTransform = values.aTransform.ref.value;
+                        instanceCount = values.uInstanceCount.ref.value;
+                        instanceIndex = 0;
+                        _b.label = 1;
+                    case 1:
+                        if (!(instanceIndex < instanceCount)) return [3 /*break*/, 5];
+                        if (!ctx.shouldUpdate) return [3 /*break*/, 3];
+                        return [4 /*yield*/, ctx.update({ current: instanceIndex + 1 })];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        _a = StlExporter.getInstance(input, instanceIndex), vertices = _a.vertices, indices = _a.indices, vertexCount = _a.vertexCount, drawCount = _a.drawCount;
+                        linear_algebra_1.Mat4.fromArray(t, aTransform, instanceIndex * 16);
+                        linear_algebra_1.Mat4.mul(t, this.centerTransform, t);
+                        vertexArray = new Float32Array(vertexCount * 3);
+                        for (i = 0; i < vertexCount; ++i) {
+                            v3transformMat4(tmpV, v3fromArray(tmpV, vertices, i * stride), t);
+                            v3toArray(tmpV, vertexArray, i * 3);
+                        }
+                        triangleBuffer = new ArrayBuffer(50 * drawCount);
+                        dataView = new DataView(triangleBuffer);
+                        for (i = 0; i < drawCount; i += 3) {
+                            v3fromArray(v1, vertexArray, (isGeoTexture ? i : indices[i]) * 3);
+                            v3fromArray(v2, vertexArray, (isGeoTexture ? i + 1 : indices[i + 1]) * 3);
+                            v3fromArray(v3, vertexArray, (isGeoTexture ? i + 2 : indices[i + 2]) * 3);
+                            v3triangleNormal(tmpV, v1, v2, v3);
+                            byteOffset = 50 * i;
+                            dataView.setFloat32(byteOffset, tmpV[0], true);
+                            dataView.setFloat32(byteOffset + 4, tmpV[1], true);
+                            dataView.setFloat32(byteOffset + 8, tmpV[2], true);
+                            dataView.setFloat32(byteOffset + 12, v1[0], true);
+                            dataView.setFloat32(byteOffset + 16, v1[1], true);
+                            dataView.setFloat32(byteOffset + 20, v1[2], true);
+                            dataView.setFloat32(byteOffset + 24, v2[0], true);
+                            dataView.setFloat32(byteOffset + 28, v2[1], true);
+                            dataView.setFloat32(byteOffset + 32, v2[2], true);
+                            dataView.setFloat32(byteOffset + 36, v3[0], true);
+                            dataView.setFloat32(byteOffset + 40, v3[1], true);
+                            dataView.setFloat32(byteOffset + 44, v3[2], true);
+                        }
+                        this.triangleBuffers.push(triangleBuffer);
+                        this.triangleCount += drawCount;
+                        _b.label = 4;
+                    case 4:
+                        ++instanceIndex;
+                        return [3 /*break*/, 1];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    StlExporter.prototype.getData = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var stl, dataView, byteOffset, _i, _a, buffer;
+            return (0, tslib_1.__generator)(this, function (_b) {
+                stl = new Uint8Array(84 + 50 * this.triangleCount);
+                (0, ascii_1.asciiWrite)(stl, "Exported from Mol* ".concat(version_1.PLUGIN_VERSION));
+                dataView = new DataView(stl.buffer);
+                dataView.setUint32(80, this.triangleCount, true);
+                byteOffset = 84;
+                for (_i = 0, _a = this.triangleBuffers; _i < _a.length; _i++) {
+                    buffer = _a[_i];
+                    stl.set(new Uint8Array(buffer), byteOffset);
+                    byteOffset += buffer.byteLength;
+                }
+                return [2 /*return*/, { stl: stl }];
+            });
+        });
+    };
+    StlExporter.prototype.getBlob = function (ctx) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var _a;
+            return (0, tslib_1.__generator)(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = Blob.bind;
+                        return [4 /*yield*/, this.getData()];
+                    case 1: return [2 /*return*/, new (_a.apply(Blob, [void 0, [(_b.sent()).stl], { type: 'model/stl' }]))()];
+                }
+            });
+        });
+    };
+    return StlExporter;
+}(mesh_exporter_1.MeshExporter));
+exports.StlExporter = StlExporter;
+//# sourceMappingURL=stl-exporter.js.map

package/lib/commonjs/extensions/geo-export/ui.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeometryExporterUI = void 0;
+var tslib_1 = require("tslib");
+var jsx_runtime_1 = require("react/jsx-runtime");
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Sukolsak Sakshuwong <sukolsak@stanford.edu>
+ */
+var rxjs_1 = require("rxjs");
+var base_1 = require("../../mol-plugin-ui/base");
+var common_1 = require("../../mol-plugin-ui/controls/common");
+var icons_1 = require("../../mol-plugin-ui/controls/icons");
+var parameters_1 = require("../../mol-plugin-ui/controls/parameters");
+var download_1 = require("../../mol-util/download");
+var controls_1 = require("./controls");
+var GeometryExporterUI = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(GeometryExporterUI, _super);
+    function GeometryExporterUI() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.save = function () { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
+            var data, e_1;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, 3, 4]);
+                        this.setState({ busy: true });
+                        return [4 /*yield*/, this.controls.exportGeometry()];
+                    case 1:
+                        data = _a.sent();
+                        (0, download_1.download)(data.blob, data.filename);
+                        return [3 /*break*/, 4];
+                    case 2:
+                        e_1 = _a.sent();
+                        console.error(e_1);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        this.setState({ busy: false });
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); };
+        _this.viewInAR = function () { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
+            var data, a_1, e_2;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, 3, 4]);
+                        this.setState({ busy: true });
+                        return [4 /*yield*/, this.controls.exportGeometry()];
+                    case 1:
+                        data = _a.sent();
+                        a_1 = document.createElement('a');
+                        a_1.rel = 'ar';
+                        a_1.href = URL.createObjectURL(data.blob);
+                        // For in-place viewing of USDZ on iOS, the link must contain a single child that is either an img or picture.
+                        // https://webkit.org/blog/8421/viewing-augmented-reality-assets-in-safari-for-ios/
+                        a_1.appendChild(document.createElement('img'));
+                        setTimeout(function () { return URL.revokeObjectURL(a_1.href); }, 4E4); // 40s
+                        setTimeout(function () { return a_1.dispatchEvent(new MouseEvent('click')); });
+                        return [3 /*break*/, 4];
+                    case 2:
+                        e_2 = _a.sent();
+                        console.error(e_2);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        this.setState({ busy: false });
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); };
+        return _this;
+    }
+    Object.defineProperty(GeometryExporterUI.prototype, "controls", {
+        get: function () {
+            return this._controls || (this._controls = new controls_1.GeometryControls(this.plugin));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GeometryExporterUI.prototype.defaultState = function () {
+        return {
+            header: 'Export Geometry',
+            isCollapsed: true,
+            brand: { accent: 'cyan', svg: icons_1.CubeSendSvg }
+        };
+    };
+    GeometryExporterUI.prototype.renderControls = function () {
+        var _a, _b, _c, _d;
+        if (this.isARSupported === undefined) {
+            this.isARSupported = !!((_b = (_a = document.createElement('a').relList) === null || _a === void 0 ? void 0 : _a.supports) === null || _b === void 0 ? void 0 : _b.call(_a, 'ar'));
+        }
+        var ctrl = this.controls;
+        return (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)(parameters_1.ParameterControls, { params: controls_1.GeometryParams, values: ctrl.behaviors.params.value, onChangeValues: function (xs) { return ctrl.behaviors.params.next(xs); }, isDisabled: this.state.busy }, void 0), (0, jsx_runtime_1.jsx)(common_1.Button, (0, tslib_1.__assign)({ icon: icons_1.GetAppSvg, onClick: this.save, style: { marginTop: 1 }, disabled: this.state.busy || !((_c = this.plugin.canvas3d) === null || _c === void 0 ? void 0 : _c.reprCount.value) }, { children: "Save" }), void 0), this.isARSupported && ctrl.behaviors.params.value.format === 'usdz' &&
+                    (0, jsx_runtime_1.jsx)(common_1.Button, (0, tslib_1.__assign)({ icon: icons_1.CubeScanSvg, onClick: this.viewInAR, style: { marginTop: 1 }, disabled: this.state.busy || !((_d = this.plugin.canvas3d) === null || _d === void 0 ? void 0 : _d.reprCount.value) }, { children: "View in AR" }), void 0)] }, void 0);
+    };
+    GeometryExporterUI.prototype.componentDidMount = function () {
+        var _this = this;
+        var merged = (0, rxjs_1.merge)(this.controls.behaviors.params, this.plugin.canvas3d.reprCount);
+        this.subscribe(merged, function () {
+            if (!_this.state.isCollapsed)
+                _this.forceUpdate();
+        });
+    };
+    GeometryExporterUI.prototype.componentWillUnmount = function () {
+        var _a;
+        (_a = this._controls) === null || _a === void 0 ? void 0 : _a.dispose();
+        this._controls = void 0;
+    };
+    return GeometryExporterUI;
+}(base_1.CollapsableControls));
+exports.GeometryExporterUI = GeometryExporterUI;
+//# sourceMappingURL=ui.js.map

package/lib/commonjs/extensions/geo-export/usdz-exporter.js

@@ -0,0 +1,222 @@
+"use strict";
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Sukolsak Sakshuwong <sukolsak@stanford.edu>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsdzExporter = void 0;
+var tslib_1 = require("tslib");
+var ascii_1 = require("../../mol-io/common/ascii");
+var linear_algebra_1 = require("../../mol-math/linear-algebra");
+var version_1 = require("../../mol-plugin/version");
+var mol_util_1 = require("../../mol-util");
+var color_1 = require("../../mol-util/color/color");
+var zip_1 = require("../../mol-util/zip/zip");
+var mesh_exporter_1 = require("./mesh-exporter");
+// avoiding namespace lookup improved performance in Chrome (Aug 2020)
+var v3fromArray = linear_algebra_1.Vec3.fromArray;
+var v3transformMat4 = linear_algebra_1.Vec3.transformMat4;
+var v3transformMat3 = linear_algebra_1.Vec3.transformMat3;
+var mat3directionTransform = linear_algebra_1.Mat3.directionTransform;
+var UsdzExporter = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(UsdzExporter, _super);
+    function UsdzExporter(boundingBox, radius) {
+        var _this = _super.call(this) || this;
+        _this.fileExtension = 'usdz';
+        _this.meshes = [];
+        _this.materials = [];
+        _this.materialMap = new Map();
+        var t = (0, linear_algebra_1.Mat4)();
+        // scale the model so that it fits within 1 meter
+        linear_algebra_1.Mat4.fromUniformScaling(t, Math.min(1 / (radius * 2), 1));
+        // translate the model so that it sits on the ground plane (y = 0)
+        linear_algebra_1.Mat4.translate(t, t, linear_algebra_1.Vec3.create(-(boundingBox.min[0] + boundingBox.max[0]) / 2, -boundingBox.min[1], -(boundingBox.min[2] + boundingBox.max[2]) / 2));
+        _this.centerTransform = t;
+        return _this;
+    }
+    UsdzExporter.prototype.addMaterial = function (color, alpha, metalness, roughness) {
+        var hash = "".concat(color, "|").concat(alpha, "|").concat(metalness, "|").concat(roughness);
+        if (this.materialMap.has(hash))
+            return this.materialMap.get(hash);
+        var materialKey = this.materialMap.size;
+        this.materialMap.set(hash, materialKey);
+        var _a = color_1.Color.toRgbNormalized(color).map(function (v) { return Math.round(v * 1000) / 1000; }), r = _a[0], g = _a[1], b = _a[2];
+        this.materials.push("\ndef Material \"material".concat(materialKey, "\"\n{\n    token outputs:surface.connect = </material").concat(materialKey, "/shader.outputs:surface>\n    def Shader \"shader\"\n    {\n        uniform token info:id = \"UsdPreviewSurface\"\n        color3f inputs:diffuseColor = (").concat(r, ",").concat(g, ",").concat(b, ")\n        float inputs:opacity = ").concat(alpha, "\n        float inputs:metallic = ").concat(metalness, "\n        float inputs:roughness = ").concat(roughness, "\n        token outputs:surface\n    }\n}\n"));
+        return materialKey;
+    };
+    UsdzExporter.prototype.addMeshWithColors = function (input) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var mesh, values, isGeoTexture, webgl, ctx, t, n, tmpV, stride, colorType, overpaintType, transparencyType, uAlpha, aTransform, instanceCount, metalness, roughness, interpolatedColors, interpolatedOverpaint, stride_1, interpolatedTransparency, stride_2, _loop_1, this_1, instanceIndex;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        mesh = input.mesh, values = input.values, isGeoTexture = input.isGeoTexture, webgl = input.webgl, ctx = input.ctx;
+                        t = (0, linear_algebra_1.Mat4)();
+                        n = (0, linear_algebra_1.Mat3)();
+                        tmpV = (0, linear_algebra_1.Vec3)();
+                        stride = isGeoTexture ? 4 : 3;
+                        colorType = values.dColorType.ref.value;
+                        overpaintType = values.dOverpaintType.ref.value;
+                        transparencyType = values.dTransparencyType.ref.value;
+                        uAlpha = values.uAlpha.ref.value;
+                        aTransform = values.aTransform.ref.value;
+                        instanceCount = values.uInstanceCount.ref.value;
+                        metalness = values.uMetalness.ref.value;
+                        roughness = values.uRoughness.ref.value;
+                        if (colorType === 'volume' || colorType === 'volumeInstance') {
+                            interpolatedColors = UsdzExporter.getInterpolatedColors(webgl, { vertices: mesh.vertices, vertexCount: mesh.vertexCount, values: values, stride: stride, colorType: colorType });
+                        }
+                        if (overpaintType === 'volumeInstance') {
+                            stride_1 = isGeoTexture ? 4 : 3;
+                            interpolatedOverpaint = UsdzExporter.getInterpolatedOverpaint(webgl, { vertices: mesh.vertices, vertexCount: mesh.vertexCount, values: values, stride: stride_1, colorType: overpaintType });
+                        }
+                        if (transparencyType === 'volumeInstance') {
+                            stride_2 = isGeoTexture ? 4 : 3;
+                            interpolatedTransparency = UsdzExporter.getInterpolatedTransparency(webgl, { vertices: mesh.vertices, vertexCount: mesh.vertexCount, values: values, stride: stride_2, colorType: transparencyType });
+                        }
+                        return [4 /*yield*/, ctx.update({ isIndeterminate: false, current: 0, max: instanceCount })];
+                    case 1:
+                        _a.sent();
+                        _loop_1 = function (instanceIndex) {
+                            var _b, vertices, normals, indices, groups, vertexCount, drawCount, vertexBuilder, normalBuilder, indexBuilder, i, i, geoData, i, v, quantizedColors, i, v, color, faceIndicesByMaterial, i, color, transparency, alpha, materialKey, faceIndices, materialBinding, materialKey, geomSubsets_1;
+                            return (0, tslib_1.__generator)(this, function (_c) {
+                                switch (_c.label) {
+                                    case 0:
+                                        if (!ctx.shouldUpdate) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, ctx.update({ current: instanceIndex + 1 })];
+                                    case 1:
+                                        _c.sent();
+                                        _c.label = 2;
+                                    case 2:
+                                        _b = UsdzExporter.getInstance(input, instanceIndex), vertices = _b.vertices, normals = _b.normals, indices = _b.indices, groups = _b.groups, vertexCount = _b.vertexCount, drawCount = _b.drawCount;
+                                        linear_algebra_1.Mat4.fromArray(t, aTransform, instanceIndex * 16);
+                                        linear_algebra_1.Mat4.mul(t, this_1.centerTransform, t);
+                                        mat3directionTransform(n, t);
+                                        vertexBuilder = mol_util_1.StringBuilder.create();
+                                        normalBuilder = mol_util_1.StringBuilder.create();
+                                        indexBuilder = mol_util_1.StringBuilder.create();
+                                        // position
+                                        for (i = 0; i < vertexCount; ++i) {
+                                            v3transformMat4(tmpV, v3fromArray(tmpV, vertices, i * stride), t);
+                                            mol_util_1.StringBuilder.writeSafe(vertexBuilder, (i === 0) ? '(' : ',(');
+                                            mol_util_1.StringBuilder.writeFloat(vertexBuilder, tmpV[0], 10000);
+                                            mol_util_1.StringBuilder.writeSafe(vertexBuilder, ',');
+                                            mol_util_1.StringBuilder.writeFloat(vertexBuilder, tmpV[1], 10000);
+                                            mol_util_1.StringBuilder.writeSafe(vertexBuilder, ',');
+                                            mol_util_1.StringBuilder.writeFloat(vertexBuilder, tmpV[2], 10000);
+                                            mol_util_1.StringBuilder.writeSafe(vertexBuilder, ')');
+                                        }
+                                        // normal
+                                        for (i = 0; i < vertexCount; ++i) {
+                                            v3transformMat3(tmpV, v3fromArray(tmpV, normals, i * stride), n);
+                                            mol_util_1.StringBuilder.writeSafe(normalBuilder, (i === 0) ? '(' : ',(');
+                                            mol_util_1.StringBuilder.writeFloat(normalBuilder, tmpV[0], 100);
+                                            mol_util_1.StringBuilder.writeSafe(normalBuilder, ',');
+                                            mol_util_1.StringBuilder.writeFloat(normalBuilder, tmpV[1], 100);
+                                            mol_util_1.StringBuilder.writeSafe(normalBuilder, ',');
+                                            mol_util_1.StringBuilder.writeFloat(normalBuilder, tmpV[2], 100);
+                                            mol_util_1.StringBuilder.writeSafe(normalBuilder, ')');
+                                        }
+                                        geoData = { values: values, groups: groups, vertexCount: vertexCount, instanceIndex: instanceIndex, isGeoTexture: isGeoTexture };
+                                        // face
+                                        for (i = 0; i < drawCount; ++i) {
+                                            v = isGeoTexture ? i : indices[i];
+                                            if (i > 0)
+                                                mol_util_1.StringBuilder.writeSafe(indexBuilder, ',');
+                                            mol_util_1.StringBuilder.writeInteger(indexBuilder, v);
+                                        }
+                                        quantizedColors = new Uint8Array(drawCount * 3);
+                                        for (i = 0; i < drawCount; i += 3) {
+                                            v = isGeoTexture ? i : indices[i];
+                                            color = UsdzExporter.getColor(v, geoData, interpolatedColors, interpolatedOverpaint);
+                                            color_1.Color.toArray(color, quantizedColors, i);
+                                        }
+                                        UsdzExporter.quantizeColors(quantizedColors, vertexCount);
+                                        faceIndicesByMaterial = new Map();
+                                        for (i = 0; i < drawCount; i += 3) {
+                                            color = color_1.Color.fromArray(quantizedColors, i);
+                                            transparency = UsdzExporter.getTransparency(i, geoData, interpolatedTransparency);
+                                            alpha = Math.round(uAlpha * (1 - transparency) * 10) / 10;
+                                            materialKey = this_1.addMaterial(color, alpha, metalness, roughness);
+                                            faceIndices = faceIndicesByMaterial.get(materialKey);
+                                            if (faceIndices === undefined) {
+                                                faceIndices = [];
+                                                faceIndicesByMaterial.set(materialKey, faceIndices);
+                                            }
+                                            faceIndices.push(i / 3);
+                                        }
+                                        materialBinding = void 0;
+                                        if (faceIndicesByMaterial.size === 1) {
+                                            materialKey = faceIndicesByMaterial.keys().next().value;
+                                            materialBinding = "rel material:binding = </material".concat(materialKey, ">");
+                                        }
+                                        else {
+                                            geomSubsets_1 = [];
+                                            faceIndicesByMaterial.forEach(function (faceIndices, materialKey) {
+                                                geomSubsets_1.push("\n    def GeomSubset \"g".concat(materialKey, "\"\n    {\n        uniform token elementType = \"face\"\n        uniform token familyName = \"materialBind\"\n        int[] indices = [").concat(faceIndices.join(','), "]\n        rel material:binding = </material").concat(materialKey, ">\n    }\n"));
+                                            });
+                                            materialBinding = geomSubsets_1.join('');
+                                        }
+                                        this_1.meshes.push("\ndef Mesh \"mesh".concat(this_1.meshes.length, "\"\n{\n    int[] faceVertexCounts = [").concat(new Array(drawCount / 3).fill(3).join(','), "]\n    int[] faceVertexIndices = [").concat(mol_util_1.StringBuilder.getString(indexBuilder), "]\n    point3f[] points = [").concat(mol_util_1.StringBuilder.getString(vertexBuilder), "]\n    normal3f[] primvars:normals = [").concat(mol_util_1.StringBuilder.getString(normalBuilder), "] (\n        interpolation = \"vertex\"\n    )\n    uniform token subdivisionScheme = \"none\"\n    ").concat(materialBinding, "\n}\n"));
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        instanceIndex = 0;
+                        _a.label = 2;
+                    case 2:
+                        if (!(instanceIndex < instanceCount)) return [3 /*break*/, 5];
+                        return [5 /*yield**/, _loop_1(instanceIndex)];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        ++instanceIndex;
+                        return [3 /*break*/, 2];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    UsdzExporter.prototype.getData = function (ctx) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var header, usda, usdaData, zipDataObj;
+            var _a, _b;
+            return (0, tslib_1.__generator)(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        header = "#usda 1.0\n(\n    customLayerData = {\n        string creator = \"Mol* ".concat(version_1.PLUGIN_VERSION, "\"\n    }\n    metersPerUnit = 1\n)\n");
+                        usda = (0, tslib_1.__spreadArray)((0, tslib_1.__spreadArray)([header], this.materials, true), this.meshes, true).join('');
+                        usdaData = new Uint8Array(usda.length);
+                        (0, ascii_1.asciiWrite)(usdaData, usda);
+                        zipDataObj = (_a = {},
+                            _a['model.usda'] = usdaData,
+                            _a);
+                        _b = {};
+                        return [4 /*yield*/, (0, zip_1.zip)(ctx, zipDataObj, true)];
+                    case 1: return [2 /*return*/, (_b.usdz = _c.sent(),
+                            _b)];
+                }
+            });
+        });
+    };
+    UsdzExporter.prototype.getBlob = function (ctx) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var usdz;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getData(ctx)];
+                    case 1:
+                        usdz = (_a.sent()).usdz;
+                        return [2 /*return*/, new Blob([usdz], { type: 'model/vnd.usdz+zip' })];
+                }
+            });
+        });
+    };
+    return UsdzExporter;
+}(mesh_exporter_1.MeshExporter));
+exports.UsdzExporter = UsdzExporter;
+//# sourceMappingURL=usdz-exporter.js.map

package/lib/commonjs/extensions/model-archive/quality-assessment/behavior.d.ts

@@ -12,7 +12,7 @@ export declare const MAQualityAssessment: import("../../../mol-state/transformer
 }>;
 export declare const QualityAssessmentPLDDTPreset: StructureRepresentationPresetProvider<{
     ignoreHydrogens: boolean | undefined;
-    quality: "custom" | "auto" | "highest" | "higher" | "high" | "medium" | "low" | "lower" | "lowest" | undefined;
+    quality: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest" | undefined;
     theme: PD.Normalize<{
         globalName: any;
         carbonColor: any;
@@ -40,7 +40,7 @@ export declare const QualityAssessmentPLDDTPreset: StructureRepresentationPreset
 }>;
 export declare const QualityAssessmentQmeanPreset: StructureRepresentationPresetProvider<{
     ignoreHydrogens: boolean | undefined;
-    quality: "custom" | "auto" | "highest" | "higher" | "high" | "medium" | "low" | "lower" | "lowest" | undefined;
+    quality: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest" | undefined;
     theme: PD.Normalize<{
         globalName: any;
         carbonColor: any;