refactored transform-data creation

src/mol-geo/representation/shape/index.ts

@@ -10,7 +10,7 @@ import { RepresentationProps, Representation } from '..';
 import { PickingId } from '../../util/picking';
 import { Loci, EmptyLoci, isEveryLoci } from 'mol-model/loci';
 import { MarkerAction, applyMarkerAction, createMarkers } from '../../util/marker-data';
-import { createRenderableState, createMeshValues, createIdentityTransform, DefaultMeshProps } from '../util';
+import { createRenderableState, createMeshValues, DefaultMeshProps } from '../util';
 import { getMeshData } from '../../util/mesh-data';
 import { MeshValues } from 'mol-gl/renderable';
 import { ValueCell } from 'mol-util';
@@ -19,6 +19,7 @@ import { Shape } from 'mol-model/shape';
 import { LocationIterator } from '../../util/location-iterator';
 import { createColors } from '../structure/visual/util/common';
 import { OrderedSet, Interval } from 'mol-data/int';
+import { createIdentityTransform } from '../../util/transform-data';
 
 export interface ShapeRepresentation<P extends RepresentationProps = {}> extends Representation<Shape, P> { }
 

src/mol-geo/representation/structure/units-visual.ts

@@ -14,11 +14,11 @@ import { Mesh } from '../../mesh/mesh';
 import { MarkerAction, applyMarkerAction, createMarkers } from '../../util/marker-data';
 import { Loci, isEveryLoci, EmptyLoci } from 'mol-model/loci';
 import { MeshRenderObject } from 'mol-gl/render-object';
-import { createUnitsMeshRenderObject, createColors, createTransforms } from './visual/util/common';
+import { createUnitsMeshRenderObject, createColors } from './visual/util/common';
 import { deepEqual, ValueCell, UUID } from 'mol-util';
 import { updateMeshValues, updateRenderableState } from '../util';
 import { Interval } from 'mol-data/int';
-import { fillSerial } from 'mol-util/array';
+import { createTransforms } from '../../util/transform-data';
 
 export interface UnitsVisual<P extends RepresentationProps = {}> extends Visual<Unit.SymmetryGroup, P> { }
 
@@ -93,8 +93,6 @@ export function UnitsMeshVisual<P extends UnitsMeshProps>(builder: UnitsMeshVisu
             const { instanceCount, groupCount } = locationIt
             createTransforms(currentGroup, renderObject.values)
             createMarkers(instanceCount * groupCount, renderObject.values)
-            ValueCell.update(renderObject.values.instanceCount, instanceCount)
-            ValueCell.update(renderObject.values.aInstance, fillSerial(new Float32Array(instanceCount))) // TODO reuse array
             updateState.updateColor = true
         }
 

src/mol-geo/representation/structure/visual/element-point.ts

@@ -9,10 +9,9 @@ import { ValueCell } from 'mol-util/value-cell'
 import { PointRenderObject } from 'mol-gl/render-object'
 import { Unit } from 'mol-model/structure';
 import { RuntimeContext } from 'mol-task'
-
 import { UnitsVisual, DefaultStructureProps } from '..';
 import { getElementLoci, StructureElementIterator, markElement } from './util/element';
-import { createTransforms, createColors, createSizes, createUnitsPointRenderObject } from './util/common';
+import { createColors, createSizes, createUnitsPointRenderObject } from './util/common';
 import { deepEqual, UUID } from 'mol-util';
 import { Interval } from 'mol-data/int';
 import { PickingId } from '../../../util/picking';
@@ -22,6 +21,7 @@ import { Vec3 } from 'mol-math/linear-algebra';
 import { fillSerial } from 'mol-util/array';
 import { SizeThemeProps } from 'mol-view/theme/size';
 import { LocationIterator } from '../../../util/location-iterator';
+import { createTransforms } from '../../../util/transform-data';
 
 export const DefaultElementPointProps = {
     ...DefaultStructureProps,
@@ -103,8 +103,6 @@ export function ElementPointVisual(): UnitsVisual<ElementPointProps> {
                     const { instanceCount, groupCount } = locationIt
                     createTransforms(currentGroup, renderObject.values)
                     createMarkers(instanceCount * groupCount, renderObject.values)
-                    ValueCell.update(renderObject.values.instanceCount, instanceCount)
-                    ValueCell.update(renderObject.values.aInstance, fillSerial(new Float32Array(instanceCount))) // TODO reuse array
                     updateColor = true
                     updateSize = true
                 }

src/mol-geo/representation/structure/visual/util/common.ts

@@ -6,8 +6,6 @@
  */
 
 import { Unit, Structure } from 'mol-model/structure';
-import { Mat4 } from 'mol-math/linear-algebra'
-
 import { createUniformColor, ColorData, createGroupColor, createGroupInstanceColor, createInstanceColor } from '../../../../util/color-data';
 import { createUniformSize, SizeData, createGroupSize, createGroupInstanceSize, createInstanceSize } from '../../../../util/size-data';
 import { ValueCell } from 'mol-util';
@@ -15,7 +13,7 @@ import { LocationIterator } from '../../../../util/location-iterator';
 import { Mesh } from '../../../../mesh/mesh';
 import { MeshValues, PointValues } from 'mol-gl/renderable';
 import { getMeshData } from '../../../../util/mesh-data';
-import { MeshProps, createMeshValues, createRenderableState, createIdentityTransform, TransformData, createPointValues } from '../../../util';
+import { MeshProps, createMeshValues, createRenderableState, createPointValues } from '../../../util';
 import { StructureProps } from '../..';
 import { createMarkers } from '../../../../util/marker-data';
 import { createMeshRenderObject, createPointRenderObject } from 'mol-gl/render-object';
@@ -24,21 +22,7 @@ import { SizeThemeProps, SizeTheme } from 'mol-view/theme/size';
 import { RuntimeContext } from 'mol-task';
 import { PointProps } from 'mol-geo/representation/structure/representation/point';
 import { fillSerial } from 'mol-util/array';
-
-export function createTransforms({ units }: Unit.SymmetryGroup, transformData?: TransformData) {
-    const unitCount = units.length
-    const n = unitCount * 16
-    const array = transformData && transformData.aTransform && transformData.aTransform.ref.value.length >= n ? transformData.aTransform.ref.value : new Float32Array(n)
-    for (let i = 0; i < unitCount; i++) {
-        Mat4.toArray(units[i].conformation.operator.matrix, array, i * 16)
-    }
-    if (transformData) {
-        ValueCell.update(transformData.aTransform, array)
-        return transformData
-    } else {
-        return { aTransform: ValueCell.create(array) }
-    }
-}
+import { TransformData, createIdentityTransform, createTransforms } from '../../../../util/transform-data';
 
 export function createColors(ctx: RuntimeContext, locationIt: LocationIterator, props: ColorThemeProps, colorData?: ColorData): Promise<ColorData> {
     const colorTheme = ColorTheme(props)

src/mol-geo/representation/util.ts

@@ -9,8 +9,6 @@ import { BaseValues } from 'mol-gl/renderable/schema';
 import { MeshValues, RenderableState } from 'mol-gl/renderable';
 import { defaults } from 'mol-util';
 import { Structure } from 'mol-model/structure';
-import { fillSerial } from 'mol-util/array';
-import { Mat4 } from 'mol-math/linear-algebra';
 
 export const DefaultBaseProps = {
     alpha: 1,
@@ -35,31 +33,13 @@ export const DefaultPointProps = {
 }
 export type PointProps = typeof DefaultPointProps
 
-export type TransformData = {
-    aTransform: ValueCell<Float32Array>,
-}
-
-const identityTransform = new Float32Array(16)
-Mat4.toArray(Mat4.identity(), identityTransform, 0)
-export function createIdentityTransform(transformData?: TransformData): TransformData {
-    if (transformData) {
-        ValueCell.update(transformData.aTransform, identityTransform)
-        return transformData
-    } else {
-        return { aTransform: ValueCell.create(identityTransform) }
-    }
-}
-
 type Counts = { drawCount: number, groupCount: number, instanceCount: number }
 
 export function createBaseValues(props: Required<BaseProps>, counts: Counts) {
     return {
         uAlpha: ValueCell.create(props.alpha),
-        uInstanceCount: ValueCell.create(counts.instanceCount),
         uGroupCount: ValueCell.create(counts.groupCount),
-        aInstance: ValueCell.create(fillSerial(new Float32Array(counts.instanceCount))),
         drawCount: ValueCell.create(counts.drawCount),
-        instanceCount: ValueCell.create(counts.instanceCount),
         dUseFog: ValueCell.create(props.useFog),
     }
 }

src/mol-geo/util/transform-data.ts

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+
+import { ValueCell } from 'mol-util';
+import { Mat4 } from 'mol-math/linear-algebra';
+import { fillSerial } from 'mol-util/array';
+import { Unit } from 'mol-model/structure';
+
+export type TransformData = {
+    aTransform: ValueCell<Float32Array>,
+    uInstanceCount: ValueCell<number>,
+    instanceCount: ValueCell<number>,
+    aInstance: ValueCell<Float32Array>,
+}
+
+export function _createTransforms(transformArray: Float32Array, instanceCount: number, transformData?: TransformData): TransformData {
+    if (transformData) {
+        ValueCell.update(transformData.aTransform, transformArray)
+        ValueCell.update(transformData.uInstanceCount, instanceCount)
+        ValueCell.update(transformData.instanceCount, instanceCount)
+        const aInstance = transformData.aInstance.ref.value.length >= instanceCount ? transformData.aInstance.ref.value : new Float32Array(instanceCount)
+        ValueCell.update(transformData.aInstance, fillSerial(aInstance, instanceCount))
+        return transformData
+    } else {
+        return {
+            aTransform: ValueCell.create(transformArray),
+            uInstanceCount: ValueCell.create(instanceCount),
+            instanceCount: ValueCell.create(instanceCount),
+            aInstance: ValueCell.create(fillSerial(new Float32Array(instanceCount)))
+        }
+    }
+}
+
+const identityTransform = new Float32Array(16)
+Mat4.toArray(Mat4.identity(), identityTransform, 0)
+export function createIdentityTransform(transformData?: TransformData): TransformData {
+    return _createTransforms(identityTransform, 1, transformData)
+}
+
+export function createTransforms({ units }: Unit.SymmetryGroup, transformData?: TransformData) {
+    const unitCount = units.length
+    const n = unitCount * 16
+    const array = transformData && transformData.aTransform.ref.value.length >= n ? transformData.aTransform.ref.value : new Float32Array(n)
+    for (let i = 0; i < unitCount; i++) {
+        Mat4.toArray(units[i].conformation.operator.matrix, array, i * 16)
+    }
+    return _createTransforms(array, unitCount, transformData)
+}
+

src/mol-util/array.ts

@@ -50,9 +50,8 @@ export function arrayRms(array: Helpers.NumberArray) {
     return Math.sqrt(sumSq / n)
 }
 
-/** Fill an array with serial numbers starting from 0 */
-export function fillSerial<T extends Helpers.NumberArray> (array: T) {
-    const n = array.length
-    for (let i = 0; i < n; ++i) array[ i ] = i
+/** Fill an array with serial numbers starting from 0 until n - 1 (defaults to array.length) */
+export function fillSerial<T extends Helpers.NumberArray> (array: T, n?: number) {
+    for (let i = 0, il = n ? Math.min(n, array.length) : array.length; i < il; ++i) array[ i ] = i
     return array
 }