addTube optimizations

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(

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();

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 };

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)