made `State` a generic type parameter for Representations

src/mol-repr/representation.ts

@@ -32,21 +32,21 @@ export interface RepresentationContext {
 }
 
 export type RepresentationParamsGetter<D, P extends PD.Params> = (ctx: ThemeRegistryContext, data: D) => P
-export type RepresentationFactory<D, P extends PD.Params> = (ctx: RepresentationContext, getParams: RepresentationParamsGetter<D, P>) => Representation<D, P>
+export type RepresentationFactory<D, P extends PD.Params, S extends Representation.State> = (ctx: RepresentationContext, getParams: RepresentationParamsGetter<D, P>) => Representation<D, P, S>
 
 //
 
-export interface RepresentationProvider<D, P extends PD.Params> {
+export interface RepresentationProvider<D, P extends PD.Params, S extends Representation.State> {
     readonly label: string
     readonly description: string
-    readonly factory: RepresentationFactory<D, P>
+    readonly factory: RepresentationFactory<D, P, S>
     readonly getParams: RepresentationParamsGetter<D, P>
     readonly defaultValues: PD.Values<P>
     readonly defaultColorTheme: string
     readonly defaultSizeTheme: string
 }
 
-export type AnyRepresentationProvider = RepresentationProvider<any, {}>
+export type AnyRepresentationProvider = RepresentationProvider<any, {}, Representation.State>
 
 export const EmptyRepresentationProvider = {
     label: '',
@@ -56,9 +56,9 @@ export const EmptyRepresentationProvider = {
     defaultValues: {}
 }
 
-export class RepresentationRegistry<D> {
-    private _list: { name: string, provider: RepresentationProvider<D, any> }[] = []
-    private _map = new Map<string, RepresentationProvider<D, any>>()
+export class RepresentationRegistry<D, S extends Representation.State> {
+    private _list: { name: string, provider: RepresentationProvider<D, any, any> }[] = []
+    private _map = new Map<string, RepresentationProvider<D, any, any>>()
 
     get default() { return this._list[0]; }
     get types(): [string, string][] {
@@ -67,7 +67,7 @@ export class RepresentationRegistry<D> {
 
     constructor() {};
 
-    add<P extends PD.Params>(name: string, provider: RepresentationProvider<D, P>) {
+    add<P extends PD.Params>(name: string, provider: RepresentationProvider<D, P, S>) {
         this._list.push({ name, provider })
         this._map.set(name, provider)
     }
@@ -77,8 +77,8 @@ export class RepresentationRegistry<D> {
         this._map.delete(name)
     }
 
-    get<P extends PD.Params>(name: string): RepresentationProvider<D, P> {
-        return this._map.get(name) || EmptyRepresentationProvider as unknown as RepresentationProvider<D, P>
+    get<P extends PD.Params>(name: string): RepresentationProvider<D, P, S> {
+        return this._map.get(name) || EmptyRepresentationProvider as unknown as RepresentationProvider<D, P, S>
     }
 
     get list() {
@@ -89,7 +89,7 @@ export class RepresentationRegistry<D> {
 //
 
 export { Representation }
-interface Representation<D, P extends PD.Params = {}> {
+interface Representation<D, P extends PD.Params = {}, S extends Representation.State = Representation.State> {
     readonly label: string
     readonly updated: Subject<number>
     /** Number of addressable groups in all visuals of the representation */
@@ -97,10 +97,10 @@ interface Representation<D, P extends PD.Params = {}> {
     readonly renderObjects: ReadonlyArray<GraphicsRenderObject>
     readonly props: Readonly<PD.Values<P>>
     readonly params: Readonly<P>
-    readonly state: Readonly<Representation.State>
+    readonly state: Readonly<S>
     readonly theme: Readonly<Theme>
     createOrUpdate: (props?: Partial<PD.Values<P>>, data?: D) => Task<void>
-    setState: (state: Partial<Representation.State>) => void
+    setState: (state: Partial<S>) => void
     setTheme: (theme: Theme) => void
     getLoci: (pickingId: PickingId) => Loci
     mark: (loci: Loci, action: MarkerAction) => boolean
@@ -116,30 +116,22 @@ namespace Representation {
         syncManually: boolean
         /** A transformation applied to the representation's renderobjects */
         transform: Mat4
-        /**
-         * A set of transformations applied to the instances within the representation's renderobjects,
-         * laid out as Mat4's in a Float32Array
-         */
-        instanceTransforms: Float32Array
     }
     export function createState(): State {
-        return { visible: false, pickable: false, syncManually: false, transform: Mat4.identity(), instanceTransforms: new Float32Array(Mat4.identity()) }
+        return { visible: false, pickable: false, syncManually: false, transform: Mat4.identity(), /* instanceTransforms: new Float32Array(Mat4.identity()) */ }
     }
     export function updateState(state: State, update: Partial<State>) {
         if (update.visible !== undefined) state.visible = update.visible
         if (update.pickable !== undefined) state.pickable = update.pickable
         if (update.syncManually !== undefined) state.syncManually = update.syncManually
         if (update.transform !== undefined) Mat4.copy(state.transform, update.transform)
-        if (update.instanceTransforms !== undefined) {
-            if (update.instanceTransforms.length !== state.instanceTransforms.length) {
-                state.instanceTransforms = new Float32Array(update.instanceTransforms)
-            } else {
-                state.instanceTransforms.set(update.instanceTransforms)
-            }
-        }
+    }
+    export interface StateBuilder<S extends State> {
+        create(): S
+        update(state: S, update: Partial<S>): void
     }
 
-    export type Any = Representation<any, any>
+    export type Any = Representation<any, any, any>
     export const Empty: Any = {
         label: '', groupCount: 0, renderObjects: [], props: {}, params: {}, updated: new Subject(), state: createState(), theme: createEmptyTheme(),
         createOrUpdate: () => Task.constant('', undefined),
@@ -150,12 +142,12 @@ namespace Representation {
         destroy: () => {}
     }
 
-    export type Def<D, P extends PD.Params = {}> = { [k: string]: RepresentationFactory<D, P> }
+    export type Def<D, P extends PD.Params = {}, S extends State = State> = { [k: string]: RepresentationFactory<D, P, S> }
 
-    export function createMulti<D, P extends PD.Params = {}>(label: string, ctx: RepresentationContext, getParams: RepresentationParamsGetter<D, P>, reprDefs: Def<D, P>): Representation<D, P> {
+    export function createMulti<D, P extends PD.Params = {}, S extends State = State>(label: string, ctx: RepresentationContext, getParams: RepresentationParamsGetter<D, P>, stateBuilder: StateBuilder<S>, reprDefs: Def<D, P>): Representation<D, P, S> {
         let version = 0
         const updated = new Subject<number>()
-        const currentState = Representation.createState()
+        const currentState = stateBuilder.create()
         let currentTheme = createEmptyTheme()
 
         let currentParams: P
@@ -236,11 +228,11 @@ namespace Representation {
                 }
                 return marked
             },
-            setState: (state: Partial<State>) => {
+            setState: (state: Partial<S>) => {
                 for (let i = 0, il = reprList.length; i < il; ++i) {
                     reprList[i].setState(state)
                 }
-                Representation.updateState(currentState, state)
+                stateBuilder.update(currentState, state)
             },
             setTheme: (theme: Theme) => {
                 for (let i = 0, il = reprList.length; i < il; ++i) {
@@ -293,9 +285,7 @@ namespace Representation {
             setState: (state: Partial<State>) => {
                 if (state.visible !== undefined) Visual.setVisibility(renderObject, state.visible)
                 if (state.pickable !== undefined) Visual.setPickable(renderObject, state.pickable)
-                if (state.transform !== undefined || state.instanceTransforms !== undefined) {
-                    Visual.setTransform(renderObject, state.transform, state.instanceTransforms)
-                }
+                if (state.transform !== undefined) Visual.setTransform(renderObject, state.transform)
 
                 Representation.updateState(currentState, state)
             },

src/mol-repr/structure/complex-representation.ts

@@ -8,11 +8,11 @@
 import { Structure } from 'mol-model/structure';
 import { Task } from 'mol-task'
 import { Loci, EmptyLoci } from 'mol-model/loci';
-import { StructureRepresentation, StructureParams } from './representation';
+import { StructureRepresentation, StructureParams, StructureRepresentationStateBuilder, StructureRepresentationState } from './representation';
 import { ComplexVisual } from './complex-visual';
 import { PickingId } from 'mol-geo/geometry/picking';
 import { MarkerAction } from 'mol-geo/geometry/marker-data';
-import { RepresentationContext, RepresentationParamsGetter, Representation } from 'mol-repr/representation';
+import { RepresentationContext, RepresentationParamsGetter } from 'mol-repr/representation';
 import { Theme, createEmptyTheme } from 'mol-theme/theme';
 import { ParamDefinition as PD } from 'mol-util/param-definition';
 import { Subject } from 'rxjs';
@@ -20,7 +20,7 @@ import { Subject } from 'rxjs';
 export function ComplexRepresentation<P extends StructureParams>(label: string, ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, P>, visualCtor: () => ComplexVisual<P>): StructureRepresentation<P> {
     let version = 0
     const updated = new Subject<number>()
-    const _state = Representation.createState()
+    const _state = StructureRepresentationStateBuilder.create()
     let visual: ComplexVisual<P> | undefined
 
     let _structure: Structure

src/mol-repr/structure/registry.ts

@@ -14,12 +14,13 @@ import { CarbohydrateRepresentationProvider } from './representation/carbohydrat
 import { SpacefillRepresentationProvider } from './representation/spacefill';
 import { DistanceRestraintRepresentationProvider } from './representation/distance-restraint';
 import { PointRepresentationProvider } from './representation/point';
+import { StructureRepresentationState } from './representation';
 
-export class StructureRepresentationRegistry extends RepresentationRegistry<Structure> {
+export class StructureRepresentationRegistry extends RepresentationRegistry<Structure, StructureRepresentationState> {
     constructor() {
         super()
         Object.keys(BuiltInStructureRepresentations).forEach(name => {
-            const p = (BuiltInStructureRepresentations as { [k: string]: RepresentationProvider<Structure, any> })[name]
+            const p = (BuiltInStructureRepresentations as { [k: string]: RepresentationProvider<Structure, any, StructureRepresentationState> })[name]
             this.add(name, p)
         })
     }

src/mol-repr/structure/representation.ts

@@ -14,13 +14,27 @@ import { Points } from 'mol-geo/geometry/points/points';
 import { Lines } from 'mol-geo/geometry/lines/lines';
 import { DirectVolume } from 'mol-geo/geometry/direct-volume/direct-volume';
 import { Spheres } from 'mol-geo/geometry/spheres/spheres';
-// import { Mat4 } from 'mol-math/linear-algebra';
+import { StructureUnitTransforms } from 'mol-model/structure/structure/util/unit-transforms';
 
-export interface StructureRepresentation<P extends RepresentationProps = {}> extends Representation<Structure, P> {
-    // setUnitsTransform(unitTransforms: { [id: number]: Mat4 }): void
+export interface StructureRepresentationState extends Representation.State {
+    unitTransforms: StructureUnitTransforms | null
 }
+export const StructureRepresentationStateBuilder: Representation.StateBuilder<StructureRepresentationState> = {
+    create: () => {
+        return {
+            ...Representation.createState(),
+            unitTransforms: null
+        }
+    },
+    update: (state: StructureRepresentationState, update: Partial<StructureRepresentationState>) => {
+        Representation.updateState(state, update)
+        if (update.unitTransforms !== undefined) state.unitTransforms = update.unitTransforms
+    }
+}
+
+export interface StructureRepresentation<P extends RepresentationProps = {}> extends Representation<Structure, P, StructureRepresentationState> { }
 
-export type StructureRepresentationProvider<P extends PD.Params> = RepresentationProvider<Structure, P>
+export type StructureRepresentationProvider<P extends PD.Params> = RepresentationProvider<Structure, P, StructureRepresentationState>
 
 //
 

src/mol-repr/structure/representation/ball-and-stick.ts

@@ -10,7 +10,7 @@ import { InterUnitLinkVisual, InterUnitLinkParams } from '../visual/inter-unit-l
 import { ParamDefinition as PD } from 'mol-util/param-definition';
 import { UnitsRepresentation } from '../units-representation';
 import { ComplexRepresentation } from '../complex-representation';
-import { StructureRepresentation, StructureRepresentationProvider } from '../representation';
+import { StructureRepresentation, StructureRepresentationProvider, StructureRepresentationStateBuilder } from '../representation';
 import { Representation, RepresentationParamsGetter, RepresentationContext } from 'mol-repr/representation';
 import { ThemeRegistryContext } from 'mol-theme/theme';
 import { Structure } from 'mol-model/structure';
@@ -40,7 +40,7 @@ export function getBallAndStickParams(ctx: ThemeRegistryContext, structure: Stru
 
 export type BallAndStickRepresentation = StructureRepresentation<BallAndStickParams>
 export function BallAndStickRepresentation(ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, BallAndStickParams>): BallAndStickRepresentation {
-    return Representation.createMulti('Ball & Stick', ctx, getParams, BallAndStickVisuals as unknown as Representation.Def<Structure, BallAndStickParams>)
+    return Representation.createMulti('Ball & Stick', ctx, getParams, StructureRepresentationStateBuilder, BallAndStickVisuals as unknown as Representation.Def<Structure, BallAndStickParams>)
 }
 
 export const BallAndStickRepresentationProvider: StructureRepresentationProvider<BallAndStickParams> = {

src/mol-repr/structure/representation/carbohydrate.ts

@@ -9,7 +9,7 @@ import { CarbohydrateLinkVisual, CarbohydrateLinkParams } from '../visual/carboh
 import { CarbohydrateTerminalLinkParams, CarbohydrateTerminalLinkVisual } from '../visual/carbohydrate-terminal-link-cylinder';
 import { ParamDefinition as PD } from 'mol-util/param-definition';
 import { ComplexRepresentation } from '../complex-representation';
-import { StructureRepresentation, StructureRepresentationProvider } from '../representation';
+import { StructureRepresentation, StructureRepresentationProvider, StructureRepresentationStateBuilder } from '../representation';
 import { Representation, RepresentationParamsGetter, RepresentationContext } from 'mol-repr/representation';
 import { ThemeRegistryContext } from 'mol-theme/theme';
 import { Structure } from 'mol-model/structure';
@@ -35,7 +35,7 @@ export function getCarbohydrateParams(ctx: ThemeRegistryContext, structure: Stru
 
 export type CarbohydrateRepresentation = StructureRepresentation<CarbohydrateParams>
 export function CarbohydrateRepresentation(ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, CarbohydrateParams>): CarbohydrateRepresentation {
-    return Representation.createMulti('Carbohydrate', ctx, getParams, CarbohydrateVisuals as unknown as Representation.Def<Structure, CarbohydrateParams>)
+    return Representation.createMulti('Carbohydrate', ctx, getParams, StructureRepresentationStateBuilder, CarbohydrateVisuals as unknown as Representation.Def<Structure, CarbohydrateParams>)
 }
 
 export const CarbohydrateRepresentationProvider: StructureRepresentationProvider<CarbohydrateParams> = {

src/mol-repr/structure/representation/cartoon.ts

@@ -9,7 +9,7 @@ import { PolymerGapVisual, PolymerGapParams } from '../visual/polymer-gap-cylind
 import { NucleotideBlockVisual, NucleotideBlockParams } from '../visual/nucleotide-block-mesh';
 import { ParamDefinition as PD } from 'mol-util/param-definition';
 import { UnitsRepresentation } from '../units-representation';
-import { StructureRepresentation, StructureRepresentationProvider } from '../representation';
+import { StructureRepresentation, StructureRepresentationProvider, StructureRepresentationStateBuilder } from '../representation';
 import { Representation, RepresentationParamsGetter, RepresentationContext } from 'mol-repr/representation';
 import { PolymerDirectionVisual, PolymerDirectionParams } from '../visual/polymer-direction-wedge';
 import { Structure, Unit } from 'mol-model/structure';
@@ -49,7 +49,7 @@ export function getCartoonParams(ctx: ThemeRegistryContext, structure: Structure
 
 export type CartoonRepresentation = StructureRepresentation<CartoonParams>
 export function CartoonRepresentation(ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, CartoonParams>): CartoonRepresentation {
-    return Representation.createMulti('Cartoon', ctx, getParams, CartoonVisuals as unknown as Representation.Def<Structure, CartoonParams>)
+    return Representation.createMulti('Cartoon', ctx, getParams, StructureRepresentationStateBuilder, CartoonVisuals as unknown as Representation.Def<Structure, CartoonParams>)
 }
 
 export const CartoonRepresentationProvider: StructureRepresentationProvider<CartoonParams> = {

src/mol-repr/structure/representation/distance-restraint.ts

@@ -7,7 +7,7 @@
 import { CrossLinkRestraintVisual, CrossLinkRestraintParams } from '../visual/cross-link-restraint-cylinder';
 import { ParamDefinition as PD } from 'mol-util/param-definition';
 import { ComplexRepresentation } from '../complex-representation';
-import { StructureRepresentation, StructureRepresentationProvider } from '../representation';
+import { StructureRepresentation, StructureRepresentationProvider, StructureRepresentationStateBuilder } from '../representation';
 import { Representation, RepresentationContext, RepresentationParamsGetter } from 'mol-repr/representation';
 import { ThemeRegistryContext } from 'mol-theme/theme';
 import { Structure } from 'mol-model/structure';
@@ -28,7 +28,7 @@ export function getDistanceRestraintParams(ctx: ThemeRegistryContext, structure:
 
 export type DistanceRestraintRepresentation = StructureRepresentation<DistanceRestraintParams>
 export function DistanceRestraintRepresentation(ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, DistanceRestraintParams>): DistanceRestraintRepresentation {
-    return Representation.createMulti('DistanceRestraint', ctx, getParams, DistanceRestraintVisuals as unknown as Representation.Def<Structure, DistanceRestraintParams>)
+    return Representation.createMulti('DistanceRestraint', ctx, getParams, StructureRepresentationStateBuilder, DistanceRestraintVisuals as unknown as Representation.Def<Structure, DistanceRestraintParams>)
 }
 
 export const DistanceRestraintRepresentationProvider: StructureRepresentationProvider<DistanceRestraintParams> = {

src/mol-repr/structure/representation/molecular-surface.ts

@@ -8,7 +8,7 @@ import { GaussianSurfaceVisual, GaussianSurfaceParams } from '../visual/gaussian
 import { UnitsRepresentation } from '../units-representation';
 import { GaussianWireframeVisual, GaussianWireframeParams } from '../visual/gaussian-surface-wireframe';
 import { ParamDefinition as PD } from 'mol-util/param-definition';
-import { StructureRepresentation, StructureRepresentationProvider } from '../representation';
+import { StructureRepresentation, StructureRepresentationProvider, StructureRepresentationStateBuilder } from '../representation';
 import { Representation, RepresentationParamsGetter, RepresentationContext } from 'mol-repr/representation';
 import { ThemeRegistryContext } from 'mol-theme/theme';
 import { Structure } from 'mol-model/structure';
@@ -32,7 +32,7 @@ export function getMolecularSurfaceParams(ctx: ThemeRegistryContext, structure:
 
 export type MolecularSurfaceRepresentation = StructureRepresentation<MolecularSurfaceParams>
 export function MolecularSurfaceRepresentation(ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, MolecularSurfaceParams>): MolecularSurfaceRepresentation {
-    return Representation.createMulti('Molecular Surface', ctx, getParams, MolecularSurfaceVisuals as unknown as Representation.Def<Structure, MolecularSurfaceParams>)
+    return Representation.createMulti('Molecular Surface', ctx, getParams, StructureRepresentationStateBuilder, MolecularSurfaceVisuals as unknown as Representation.Def<Structure, MolecularSurfaceParams>)
 }
 
 export const MolecularSurfaceRepresentationProvider: StructureRepresentationProvider<MolecularSurfaceParams> = {

src/mol-repr/structure/representation/molecular-volume.ts

@@ -6,7 +6,7 @@
 
 import { ParamDefinition as PD } from 'mol-util/param-definition';
 import { GaussianDensityVolumeParams, GaussianDensityVolumeVisual } from '../visual/gaussian-density-volume';
-import { StructureRepresentation, StructureRepresentationProvider, ComplexRepresentation } from '../representation';
+import { StructureRepresentation, StructureRepresentationProvider, ComplexRepresentation, StructureRepresentationStateBuilder } from '../representation';
 import { Representation, RepresentationParamsGetter, RepresentationContext } from 'mol-repr/representation';
 import { ThemeRegistryContext } from 'mol-theme/theme';
 import { Structure } from 'mol-model/structure';
@@ -25,7 +25,7 @@ export function getMolecularVolumeParams(ctx: ThemeRegistryContext, structure: S
 
 export type MolecularVolumeRepresentation = StructureRepresentation<MolecularVolumeParams>
 export function MolecularVolumeRepresentation(ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, MolecularVolumeParams>): MolecularVolumeRepresentation {
-    return Representation.createMulti('Molecular Volume', ctx, getParams, MolecularVolumeVisuals as unknown as Representation.Def<Structure, MolecularVolumeParams>)
+    return Representation.createMulti('Molecular Volume', ctx, getParams, StructureRepresentationStateBuilder, MolecularVolumeVisuals as unknown as Representation.Def<Structure, MolecularVolumeParams>)
 }
 
 export const MolecularVolumeRepresentationProvider: StructureRepresentationProvider<MolecularVolumeParams> = {

src/mol-repr/structure/representation/point.ts

@@ -7,7 +7,7 @@
 import { ElementPointVisual, ElementPointParams } from '../visual/element-point';
 import { UnitsRepresentation } from '../units-representation';
 import { ParamDefinition as PD } from 'mol-util/param-definition';
-import { StructureRepresentation, StructureRepresentationProvider } from '../representation';
+import { StructureRepresentation, StructureRepresentationProvider, StructureRepresentationStateBuilder } from '../representation';
 import { Representation, RepresentationParamsGetter, RepresentationContext } from 'mol-repr/representation';
 import { ThemeRegistryContext } from 'mol-theme/theme';
 import { Structure } from 'mol-model/structure';
@@ -28,7 +28,7 @@ export function getPointParams(ctx: ThemeRegistryContext, structure: Structure)
 
 export type PointRepresentation = StructureRepresentation<PointParams>
 export function PointRepresentation(ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, PointParams>): PointRepresentation {
-    return Representation.createMulti('Point', ctx, getParams, PointVisuals as unknown as Representation.Def<Structure, PointParams>)
+    return Representation.createMulti('Point', ctx, getParams, StructureRepresentationStateBuilder, PointVisuals as unknown as Representation.Def<Structure, PointParams>)
 }
 
 export const PointRepresentationProvider: StructureRepresentationProvider<PointParams> = {

src/mol-repr/structure/representation/spacefill.ts

@@ -7,7 +7,7 @@
 import { getElementSphereVisual, ElementSphereParams } from '../visual/element-sphere';
 import { UnitsRepresentation } from '../units-representation';
 import { ParamDefinition as PD } from 'mol-util/param-definition';
-import { StructureRepresentation, StructureRepresentationProvider } from '../representation';
+import { StructureRepresentation, StructureRepresentationProvider, StructureRepresentationStateBuilder } from '../representation';
 import { RepresentationParamsGetter, RepresentationContext, Representation } from 'mol-repr/representation';
 import { ThemeRegistryContext } from 'mol-theme/theme';
 import { Structure } from 'mol-model/structure';
@@ -28,7 +28,7 @@ export function getSpacefillParams(ctx: ThemeRegistryContext, structure: Structu
 
 export type SpacefillRepresentation = StructureRepresentation<SpacefillParams>
 export function SpacefillRepresentation(ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, SpacefillParams>): SpacefillRepresentation {
-    return Representation.createMulti('Spacefill', ctx, getParams, SpacefillVisuals as unknown as Representation.Def<Structure, SpacefillParams>)
+    return Representation.createMulti('Spacefill', ctx, getParams, StructureRepresentationStateBuilder, SpacefillVisuals as unknown as Representation.Def<Structure, SpacefillParams>)
 }
 
 export const SpacefillRepresentationProvider: StructureRepresentationProvider<SpacefillParams> = {

src/mol-repr/structure/units-representation.ts

@@ -8,11 +8,11 @@
 import { Structure, Unit } from 'mol-model/structure';
 import { Task } from 'mol-task'
 import { GraphicsRenderObject } from 'mol-gl/render-object';
-import { RepresentationContext, RepresentationParamsGetter, Representation } from '../representation';
+import { RepresentationContext, RepresentationParamsGetter } from '../representation';
 import { Visual } from '../visual';
 import { Loci, EmptyLoci, isEmptyLoci } from 'mol-model/loci';
 import { StructureGroup } from './units-visual';
-import { StructureRepresentation, StructureParams } from './representation';
+import { StructureRepresentation, StructureParams, StructureRepresentationState, StructureRepresentationStateBuilder } from './representation';
 import { PickingId } from 'mol-geo/geometry/picking';
 import { MarkerAction } from 'mol-geo/geometry/marker-data';
 import { Theme, createEmptyTheme } from 'mol-theme/theme';
@@ -31,7 +31,7 @@ export interface UnitsVisual<P extends UnitsParams> extends Visual<StructureGrou
 export function UnitsRepresentation<P extends UnitsParams>(label: string, ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, P>, visualCtor: () => UnitsVisual<P>): StructureRepresentation<P> {
     let version = 0
     const updated = new Subject<number>()
-    const _state = Representation.createState()
+    const _state = StructureRepresentationStateBuilder.create()
     let visuals = new Map<number, { group: Unit.SymmetryGroup, visual: UnitsVisual<P> }>()
 
     let _structure: Structure

src/mol-repr/volume/registry.ts

@@ -4,16 +4,16 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
-import { RepresentationProvider, RepresentationRegistry } from '../representation';
+import { RepresentationProvider, RepresentationRegistry, Representation } from '../representation';
 import { VolumeData } from 'mol-model/volume';
 import { IsosurfaceRepresentationProvider } from './isosurface-mesh';
 import { DirectVolumeRepresentationProvider } from './direct-volume';
 
-export class VolumeRepresentationRegistry extends RepresentationRegistry<VolumeData> {
+export class VolumeRepresentationRegistry extends RepresentationRegistry<VolumeData, Representation.State> {
     constructor() {
         super()
         Object.keys(BuiltInVolumeRepresentations).forEach(name => {
-            const p = (BuiltInVolumeRepresentations as { [k: string]: RepresentationProvider<VolumeData, any> })[name]
+            const p = (BuiltInVolumeRepresentations as { [k: string]: RepresentationProvider<VolumeData, any, Representation.State> })[name]
             this.add(name, p)
         })
     }

src/mol-repr/volume/representation.ts

@@ -129,7 +129,7 @@ export function VolumeVisual<P extends VolumeParams>(builder: VolumeVisualGeomet
         setPickable(pickable: boolean) {
             Visual.setPickable(renderObject, pickable)
         },
-        setTransform(matrix?: Mat4, instanceMatrices?: Float32Array) {
+        setTransform(matrix?: Mat4, instanceMatrices?: Float32Array | null) {
             Visual.setTransform(renderObject, matrix, instanceMatrices)
         },
         destroy() {
@@ -141,7 +141,7 @@ export function VolumeVisual<P extends VolumeParams>(builder: VolumeVisualGeomet
 
 export interface VolumeRepresentation<P extends VolumeParams> extends Representation<VolumeData, P> { }
 
-export type VolumeRepresentationProvider<P extends VolumeParams> = RepresentationProvider<VolumeData, P>
+export type VolumeRepresentationProvider<P extends VolumeParams> = RepresentationProvider<VolumeData, P, Representation.State>
 
 //