Fix attribute transition

modules/core/src/lib/attribute/attribute-manager.ts

@@ -275,7 +275,7 @@ export default class AttributeManager {
    * @return {Object} attributes - descriptors
    */
   getAttributes(): {[id: string]: Attribute} {
-    return this.attributes;
+    return {...this.attributes, ...this.attributeTransitionManager.getAttributes()};
   }
 
   /**

modules/core/src/lib/attribute/attribute-transition-manager.ts

@@ -6,10 +6,10 @@ import log from '../../utils/log';
 
 import type {Device} from '@luma.gl/core';
 import type {Timeline} from '@luma.gl/engine';
-import type GPUTransition from '../../transitions/gpu-transition';
+import type {GPUTransition} from '../../transitions/gpu-transition';
 import type {ConstructorOf} from '../../types/types';
 import type Attribute from './attribute';
-import type {TransitionSettings} from './attribute-transition-utils';
+import type {TransitionSettings} from './transition-settings';
 
 const TRANSITION_TYPES: Record<string, ConstructorOf<GPUTransition>> = {
   interpolation: GPUInterpolationTransition,
@@ -129,7 +129,7 @@ export default class AttributeTransitionManager {
 
   /* Private methods */
   private _removeTransition(attributeName: string): void {
-    this.transitions[attributeName].cancel();
+    this.transitions[attributeName].delete();
     delete this.transitions[attributeName];
   }
 

modules/core/src/lib/attribute/attribute.ts

@@ -10,7 +10,7 @@ import {createIterable, getAccessorFromBuffer} from '../../utils/iterable-utils'
 import {fillArray} from '../../utils/flatten';
 import * as range from '../../utils/range';
 import {bufferLayoutEqual} from './gl-utils';
-import {normalizeTransitionSettings, TransitionSettings} from './attribute-transition-utils';
+import {normalizeTransitionSettings, TransitionSettings} from './transition-settings';
 import type {Device, Buffer, BufferLayout} from '@luma.gl/core';
 
 import type {NumericArray, TypedArray} from '../../types/types';

modules/core/src/lib/attribute/data-column.ts

@@ -344,6 +344,8 @@ export default class DataColumn<Options, State> {
           constant?: boolean;
           value?: NumericArray;
           buffer?: Buffer;
+          /** Set to `true` if supplying float values to a unorm attribute */
+          normalized?: boolean;
         } & Partial<BufferAccessor>)
   ): boolean {
     const {state} = this;

modules/core/src/lib/attribute/transition-settings.ts

@@ -0,0 +1,59 @@
+import {NumericArray} from '../../types/types';
+
+export interface TransitionSettings {
+  type: string;
+  /** Callback to get the value that the entering vertices are transitioning from. */
+  enter?: (toValue: NumericArray, chunk?: NumericArray) => NumericArray;
+  /** Callback when the transition is started */
+  onStart?: () => void;
+  /** Callback when the transition is done */
+  onEnd?: () => void;
+  /** Callback when the transition is interrupted */
+  onInterrupt?: () => void;
+}
+
+export type InterpolationTransitionSettings = TransitionSettings & {
+  type?: 'interpolation';
+  /** Duration of the transition animation, in milliseconds */
+  duration: number;
+  /** Easing function that maps a value from [0, 1] to [0, 1], see [http://easings.net/](http://easings.net/) */
+  easing?: (t: number) => number;
+};
+
+export type SpringTransitionSettings = TransitionSettings & {
+  type: 'spring';
+  /** "Tension" factor for the spring */
+  stiffness: number;
+  /** "Friction" factor that counteracts the spring's acceleration */
+  damping: number;
+};
+
+const DEFAULT_TRANSITION_SETTINGS = {
+  interpolation: {
+    duration: 0,
+    easing: t => t
+  },
+  spring: {
+    stiffness: 0.05,
+    damping: 0.5
+  }
+};
+
+export function normalizeTransitionSettings(
+  userSettings: number | InterpolationTransitionSettings | SpringTransitionSettings,
+  layerSettings?: boolean | Partial<TransitionSettings>
+): TransitionSettings | null {
+  if (!userSettings) {
+    return null;
+  }
+  if (Number.isFinite(userSettings)) {
+    userSettings = {type: 'interpolation', duration: userSettings as number};
+  }
+  const type = (userSettings as TransitionSettings).type || 'interpolation';
+  return {
+    ...DEFAULT_TRANSITION_SETTINGS[type],
+    ...(layerSettings as TransitionSettings),
+    ...(userSettings as TransitionSettings),
+    type
+  };
+}

modules/core/src/lib/uniform-transition-manager.ts

@@ -1,4 +1,4 @@
-import {normalizeTransitionSettings} from './attribute/attribute-transition-utils';
+import {normalizeTransitionSettings} from './attribute/transition-settings';
 import CPUInterpolationTransition from '../transitions/cpu-interpolation-transition';
 import CPUSpringTransition from '../transitions/cpu-spring-transition';
 import log from '../utils/log';