diff --git a/src/mol-geo/geometry/mesh/builder/tube.ts b/src/mol-geo/geometry/mesh/builder/tube.ts
index eb3de091cec07adeed2b354b661be988ff42f32e..5eabb36f68052eec636f177b82e7386369d0019a 100644
--- a/src/mol-geo/geometry/mesh/builder/tube.ts
+++ b/src/mol-geo/geometry/mesh/builder/tube.ts
@@ -10,14 +10,23 @@ import { ChunkedArray } from 'mol-data/util';
import { MeshBuilder } from '../mesh-builder';
const normalVector = Vec3.zero()
-const binormalVector = Vec3.zero()
+const surfacePoint = Vec3.zero()
const controlPoint = Vec3.zero()
-const tempPos = Vec3.zero()
-const a = Vec3.zero()
-const b = Vec3.zero()
const u = Vec3.zero()
const v = Vec3.zero()
+function add2AndScale2(out: Vec3, a: Vec3, b: Vec3, sa: number, sb: number) {
+ out[0] = (a[0] * sa) + (b[0] * sb);
+ out[1] = (a[1] * sa) + (b[1] * sb);
+ out[2] = (a[2] * sa) + (b[2] * sb);
+}
+
+function add3AndScale2(out: Vec3, a: Vec3, b: Vec3, c: Vec3, sa: number, sb: number) {
+ out[0] = (a[0] * sa) + (b[0] * sb) + c[0];
+ out[1] = (a[1] * sa) + (b[1] * sb) + c[1];
+ out[2] = (a[2] * sa) + (b[2] * sb) + c[2];
+}
+
export function addTube(builder: MeshBuilder, controlPoints: ArrayLike<number>, normalVectors: ArrayLike<number>, binormalVectors: ArrayLike<number>, linearSegments: number, radialSegments: number, width: number, height: number, waveFactor: number, startCap: boolean, endCap: boolean) {
const { currentGroup, vertices, normals, indices, groups } = builder.state
@@ -28,6 +37,7 @@ export function addTube(builder: MeshBuilder, controlPoints: ArrayLike<number>,
const i3 = i * 3
Vec3.fromArray(u, normalVectors, i3)
Vec3.fromArray(v, binormalVectors, i3)
+ Vec3.fromArray(controlPoint, controlPoints, i3)
const tt = di * i - 0.5;
const ff = 1 + (waveFactor - 1) * (Math.cos(2 * Math.PI * tt) + 1);
@@ -36,27 +46,11 @@ export function addTube(builder: MeshBuilder, controlPoints: ArrayLike<number>,
for (let j = 0; j < radialSegments; ++j) {
const t = 2 * Math.PI * j / radialSegments;
- Vec3.copy(a, u)
- Vec3.copy(b, v)
- Vec3.add(
- normalVector,
- Vec3.scale(a, a, w * Math.cos(t)),
- Vec3.scale(b, b, h * Math.sin(t))
- )
-
- Vec3.copy(a, u)
- Vec3.copy(b, v)
- Vec3.add(
- binormalVector,
- Vec3.scale(a, a, h * Math.cos(t)),
- Vec3.scale(b, b, w * Math.sin(t))
- )
+ add3AndScale2(surfacePoint, u, v, controlPoint, h * Math.cos(t), w * Math.sin(t))
+ add2AndScale2(normalVector, u, v, w * Math.cos(t), h * Math.sin(t))
Vec3.normalize(normalVector, normalVector)
- Vec3.fromArray(tempPos, controlPoints, i3)
- Vec3.add(tempPos, tempPos, binormalVector)
-
- ChunkedArray.add3(vertices, tempPos[0], tempPos[1], tempPos[2]);
+ ChunkedArray.add3(vertices, surfacePoint[0], surfacePoint[1], surfacePoint[2]);
ChunkedArray.add3(normals, normalVector[0], normalVector[1], normalVector[2]);
}
}
@@ -93,16 +87,9 @@ export function addTube(builder: MeshBuilder, controlPoints: ArrayLike<number>,
for (let i = 0; i < radialSegments; ++i) {
const t = 2 * Math.PI * i / radialSegments;
- Vec3.copy(a, u)
- Vec3.copy(b, v)
- Vec3.add(
- tempPos,
- Vec3.scale(a, a, height * Math.cos(t)),
- Vec3.scale(b, b, width * Math.sin(t))
- )
- Vec3.add(tempPos, controlPoint, tempPos)
+ add3AndScale2(surfacePoint, u, v, controlPoint, height * Math.cos(t), width * Math.sin(t))
- ChunkedArray.add3(vertices, tempPos[0], tempPos[1], tempPos[2]);
+ ChunkedArray.add3(vertices, surfacePoint[0], surfacePoint[1], surfacePoint[2]);
ChunkedArray.add3(normals, normalVector[0], normalVector[1], normalVector[2]);
ChunkedArray.add3(
@@ -129,16 +116,9 @@ export function addTube(builder: MeshBuilder, controlPoints: ArrayLike<number>,
for (let i = 0; i < radialSegments; ++i) {
const t = 2 * Math.PI * i / radialSegments
- Vec3.copy(a, u)
- Vec3.copy(b, v)
- Vec3.add(
- tempPos,
- Vec3.scale(a, a, height * Math.cos(t)),
- Vec3.scale(b, b, width * Math.sin(t))
- )
- Vec3.add(tempPos, controlPoint, tempPos)
+ add3AndScale2(surfacePoint, u, v, controlPoint, height * Math.cos(t), width * Math.sin(t))
- ChunkedArray.add3(vertices, tempPos[0], tempPos[1], tempPos[2]);
+ ChunkedArray.add3(vertices, surfacePoint[0], surfacePoint[1], surfacePoint[2]);
ChunkedArray.add3(normals, normalVector[0], normalVector[1], normalVector[2]);
ChunkedArray.add3(
diff --git a/src/mol-math/linear-algebra/3d/vec3.ts b/src/mol-math/linear-algebra/3d/vec3.ts
index f2f0e1427e87cd980e42d676a5a3d1f62db091a7..852537d3570f269ca0d9bb05bf596c28dc10bc2e 100644
--- a/src/mol-math/linear-algebra/3d/vec3.ts
+++ b/src/mol-math/linear-algebra/3d/vec3.ts
@@ -453,12 +453,9 @@ namespace Vec3 {
return add(out, scale(out, copy(out, vector), scalar), origin);
}
- const orthogonalizeTmp = zero();
/** Get a vector that is similar to `b` but orthogonal to `a` */
export function orthogonalize(out: Vec3, a: Vec3, b: Vec3) {
- normalize(orthogonalizeTmp, cross(orthogonalizeTmp, a, b));
- normalize(out, cross(out, orthogonalizeTmp, a));
- return out;
+ return normalize(out, cross(out, cross(out, a, b), a));
}
const triangleNormalTmpAB = zero();
diff --git a/src/mol-model/structure/model/formats/mmcif/atomic.ts b/src/mol-model/structure/model/formats/mmcif/atomic.ts
index 5b7335376caae94227ad990eff71c1637c18277b..8ae819b489f88f991e96dac5701c74f9699e8004 100644
--- a/src/mol-model/structure/model/formats/mmcif/atomic.ts
+++ b/src/mol-model/structure/model/formats/mmcif/atomic.ts
@@ -100,10 +100,7 @@ export function getAtomicHierarchyAndConformation(format: mmCIF_Format, atom_sit
}
const index = getAtomicIndex(hierarchyData, entities, hierarchySegments);
- console.time('derived')
const derived = getAtomicDerivedData(hierarchyData, index, formatData.chemicalComponentMap);
- console.timeEnd('derived')
- console.log(derived)
const hierarchyRanges = getAtomicRanges(hierarchyData, hierarchySegments, conformation, formatData.chemicalComponentMap);
const hierarchy: AtomicHierarchy = { ...hierarchyData, ...hierarchySegments, ...hierarchyRanges, index, derived };
return { sameAsPrevious: false, hierarchy, conformation };
diff --git a/src/mol-repr/structure/visual/util/polymer/curve-segment.ts b/src/mol-repr/structure/visual/util/polymer/curve-segment.ts
index 3bafdca9fba0db871e46e26aaba9f2b856535e7c..bef8bd5e91958bdf819f8b0202169699ad3f083c 100644
--- a/src/mol-repr/structure/visual/util/polymer/curve-segment.ts
+++ b/src/mol-repr/structure/visual/util/polymer/curve-segment.ts
@@ -37,7 +37,7 @@ export function interpolateCurveSegment(state: CurveSegmentState, controls: Curv
const tanA = Vec3.zero()
const tanB = Vec3.zero()
-const tB = Vec3.zero()
+const curvePoint = Vec3.zero()
export function interpolatePointsAndTangents(state: CurveSegmentState, controls: CurveSegmentControls, tension: number, shift: number) {
const { curvePoints, tangentVectors, linearSegments } = state
@@ -48,15 +48,15 @@ export function interpolatePointsAndTangents(state: CurveSegmentState, controls:
for (let j = 0; j <= linearSegments; ++j) {
const t = j * 1.0 / linearSegments;
if (t < shift1) {
- Vec3.spline(tB, p0, p1, p2, p3, t + shift, tension)
+ Vec3.spline(curvePoint, p0, p1, p2, p3, t + shift, tension)
Vec3.spline(tanA, p0, p1, p2, p3, t + shift + 0.01, tension)
Vec3.spline(tanB, p0, p1, p2, p3, t + shift - 0.01, tension)
} else {
- Vec3.spline(tB, p1, p2, p3, p4, t - shift1, tension)
+ Vec3.spline(curvePoint, p1, p2, p3, p4, t - shift1, tension)
Vec3.spline(tanA, p1, p2, p3, p4, t - shift1 + 0.01, tension)
Vec3.spline(tanB, p1, p2, p3, p4, t - shift1 - 0.01, tension)
}
- Vec3.toArray(tB, curvePoints, j * 3)
+ Vec3.toArray(curvePoint, curvePoints, j * 3)
Vec3.normalize(tangentVec, Vec3.sub(tangentVec, tanA, tanB))
Vec3.toArray(tangentVec, tangentVectors, j * 3)
}
@@ -89,11 +89,8 @@ export function interpolateNormals(state: CurveSegmentState, controls: CurveSegm
Vec3.fromArray(firstTangentVec, tangentVectors, 0)
Vec3.fromArray(lastTangentVec, tangentVectors, (n - 1) * 3)
- Vec3.normalize(tmpNormal, Vec3.sub(tmpNormal, firstControlPoint, firstDirection))
- Vec3.orthogonalize(firstNormalVec, firstTangentVec, tmpNormal)
-
- Vec3.normalize(tmpNormal, Vec3.sub(tmpNormal, lastControlPoint, lastDirection))
- Vec3.orthogonalize(lastNormalVec, lastTangentVec, tmpNormal)
+ Vec3.orthogonalize(firstNormalVec, firstTangentVec, Vec3.sub(tmpNormal, firstControlPoint, firstDirection))
+ Vec3.orthogonalize(lastNormalVec, lastTangentVec, Vec3.sub(tmpNormal, lastControlPoint, lastDirection))
if (Vec3.dot(firstNormalVec, lastNormalVec) < 0) {
Vec3.scale(lastNormalVec, lastNormalVec, -1)
@@ -103,11 +100,10 @@ export function interpolateNormals(state: CurveSegmentState, controls: CurveSegm
for (let i = 0; i < n; ++i) {
const t = i === 0 ? 0 : 1 / (n - i)
- Vec3.normalize(tmpNormal, Vec3.slerp(tmpNormal, prevNormal, lastNormalVec, t))
Vec3.fromArray(tangentVec, tangentVectors, i * 3)
- Vec3.orthogonalize(normalVec, tangentVec, tmpNormal)
+ Vec3.orthogonalize(normalVec, tangentVec, Vec3.slerp(tmpNormal, prevNormal, lastNormalVec, t))
Vec3.toArray(normalVec, normalVectors, i * 3)
Vec3.copy(prevNormal, normalVec)