@needle-tools/engine 2.24.0-pre

package/lib/engine/extensions/KHR_animation_pointer.js

@@ -0,0 +1,385 @@
+"use strict";
+// /*
+// TOPICS/PROBLEMS:
+// - extensions might need a way to override PropertyBinding to find the right target objects
+// - animating emissiveMap.offset/repeat won't work, three only uses the main map UV transform for all textures
+// - lights can't be animated right now since there's no getDependency for them
+// */
+// import { getParam } from "../engine_utils";
+// import { PropertyBinding, AnimationClip, BufferAttribute, ColorKeyframeTrack, InterpolateDiscrete, InterpolateLinear, KeyframeTrack, Matrix3, NumberKeyframeTrack, Object3D, QuaternionKeyframeTrack, VectorKeyframeTrack, Material } from "three";
+// import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+// const debug = getParam("debugkhranimation");
+// export const NEEDLE_KHR_ANIMATION_POINTER_NAME = "KHR_animation_pointer123";
+// // TBD: I'm adding
+// const extensionsArray = PropertyBinding["findNodeExtensions"];
+// if(extensionsArray){
+//     extensionsArray.push((node, path) => {
+//         if (path.startsWith(".nodes.")) {
+//             const sections = path.substring(1).split(".");
+//             let currentTarget: object | undefined;
+//             console.log(sections);
+//             for (let i = 1; i < sections.length; i++) {
+//                 const val: string = sections[i];
+//                 const isUUID = val.length == 36;
+//                 if (isUUID) {
+//                     currentTarget = node.getObjectByProperty("uuid", val);
+//                 }
+//                 else if (currentTarget && currentTarget[val]) {
+//                     const index = Number.parseInt(val);
+//                     let key: string | number = val;
+//                     if (index >= 0) key = index;
+//                     currentTarget = currentTarget[key];
+//                     if (debug)
+//                         console.log(currentTarget);
+//                 }
+//                 else {
+//                     currentTarget = find(node, x => x["sourceId"] === val);
+//                 }
+//             }
+//             // if (debug)
+//             console.log("NODE", path, currentTarget)
+//             return currentTarget;
+//         }
+//     });
+// }
+// function find(obj: THREE.Object3D, select: (obj: THREE.Object3D) => any): any {
+//     const cb = select(obj);
+//     if (cb === true) return obj;
+//     if (cb) return cb;
+//     for (let i = 0; i < obj.children.length; i++) {
+//         const child = obj.children[i];
+//         const res = find(child, select);
+//         if (res) return res;
+//     }
+//     return null;
+// }
+// const PATH_PROPERTIES = {
+//     position: 'position',
+//     scale: 'scale',
+//     translation: 'position',
+//     rotation: 'quaternion',
+//     weights: 'morphTargetInfluences'
+// };
+// const TARGET_TYPE = {
+//     node: 'node',
+//     material: 'material',
+//     light: 'light',
+// }
+// // Object.defineProperty(Object3D.prototype, 'components', {
+// //     get: function () { return this.userData.components; }
+// // });
+// const INTERPOLATION = {
+//     CUBICSPLINE: undefined, // We use a custom interpolant (GLTFCubicSplineInterpolation) for CUBICSPLINE tracks. Each
+//     // keyframe track will be initialized with a default interpolation type, then modified.
+//     LINEAR: InterpolateLinear,
+//     STEP: InterpolateDiscrete
+// };
+// export class KHR_animation_pointer implements GLTFLoaderPlugin {
+//     get name(): string {
+//         return NEEDLE_KHR_ANIMATION_POINTER_NAME;
+//     }
+//     private parser: GLTFParser;
+//     constructor(loader: GLTFParser) {
+//         this.parser = loader;
+//     }
+//     // this is just here to satisfy typescript
+//     // but actually loadAnimation exists and is called
+//     afterRoot(_result: GLTF) {
+//         return null;
+//     }
+//     async loadAnimation123(animationIndex: number) {
+//         const json = this.parser.json;
+//         const animationDef = json.animations[animationIndex];
+//         const pendingNodes: any = [];
+//         const pendingInputAccessors: any = [];
+//         const pendingOutputAccessors: any = [];
+//         const pendingSamplers: any = [];
+//         const pendingTargets: any = [];
+//         for (let i = 0, il = animationDef.channels.length; i < il; i++) {
+//             const channel = animationDef.channels[i];
+//             const sampler = animationDef.samplers[channel.sampler];
+//             const target = channel.target;
+//             // could be node ID or material ID
+//             let targetId: null | number = target.node !== undefined ? target.node : target.id; // NOTE: target.id is deprecated.
+//             const input = animationDef.parameters !== undefined ? animationDef.parameters[sampler.input] : sampler.input;
+//             const output = animationDef.parameters !== undefined ? animationDef.parameters[sampler.output] : sampler.output;
+//             let targetProperty: string | undefined = undefined;
+//             // check if this is a extension animation
+//             let type = TARGET_TYPE.node;
+//             const useExtension = target.extensions && target.extensions[NEEDLE_KHR_ANIMATION_POINTER_NAME];
+//             if (useExtension) {
+//                 const ext = target.extensions[NEEDLE_KHR_ANIMATION_POINTER_NAME];
+//                 let path: string = ext.pointer;
+//                 if (debug)
+//                     console.log("Original path: " + path);
+//                 if (!path) {
+//                     console.warn("Invalid path", ext, target);
+//                     continue;
+//                 }
+//                 if (path.startsWith("/materials/"))
+//                     type = TARGET_TYPE.material;
+//                 if (path.startsWith("/extensions/KHR_lights_punctual/lights/"))
+//                     type = TARGET_TYPE.light;
+//                 targetId = this.tryResolveNodeId(path, type);
+//                 if (targetId === null) {
+//                     console.warn("Failed resolving animation node id: " + targetId, path);
+//                     continue;
+//                 }
+//                 // TODO could be parsed better
+//                 switch (type) {
+//                     case TARGET_TYPE.material:
+//                         const pathIndex = ("/materials/" + targetId.toString() + "/").length;
+//                         const pathStart = path.substring(0, pathIndex);
+//                         targetProperty = path.substring(pathIndex);
+//                         // console.log("PROP", targetProperty, targetId, pathIndex);
+//                         switch (targetProperty) {
+//                             case "pbrMetallicRoughness/baseColorFactor":
+//                                 targetProperty = "color";
+//                                 break;
+//                             case "pbrMetallicRoughness/roughnessFactor":
+//                                 targetProperty = "roughness";
+//                                 break;
+//                             case "pbrMetallicRoughness/metallicFactor":
+//                                 targetProperty = "metalness";
+//                                 break;
+//                             case "pbrMetallicRoughness/emissiveFactor":
+//                                 targetProperty = "emissive";
+//                                 break;
+//                             case "extensions/KHR_materials_emissive_strength/emissiveStrength":
+//                                 targetProperty = "emissiveIntensity";
+//                                 break;
+//                             case "baseColorTexture/extensions/KHR_texture_transform/scale":
+//                                 targetProperty = "map/repeat";
+//                                 break;
+//                             case "baseColorTexture/extensions/KHR_texture_transform/offset":
+//                                 targetProperty = "map/offset";
+//                                 break;
+//                             case "emissiveTexture/extensions/KHR_texture_transform/scale":
+//                                 targetProperty = "emissiveMap/repeat";
+//                                 break;
+//                             case "emissiveTexture/extensions/KHR_texture_transform/offset":
+//                                 targetProperty = "emissiveMap/offset";
+//                                 break;
+//                         }
+//                         path = pathStart + targetProperty;
+//                         console.log("Path start", pathStart, "TargetProp", targetProperty, "Path", path);
+//                         break;
+//                     case TARGET_TYPE.node:
+//                         const pathIndexNode = ("/nodes/" + targetId.toString() + "/").length;
+//                         const pathStartNode = path.substring(0, pathIndexNode);
+//                         targetProperty = path.substring(pathIndexNode);
+//                         switch (targetProperty) {
+//                             case "translation":
+//                                 targetProperty = "position";
+//                                 break;
+//                             case "rotation":
+//                                 targetProperty = "quaternion";
+//                                 break;
+//                             case "scale":
+//                                 targetProperty = "scale";
+//                                 break;
+//                         }
+//                         path = pathStartNode + targetProperty;
+//                         break;
+//                     case TARGET_TYPE.light:
+//                         const pathIndexLight = ("/extensions/KHR_lights_punctual/lights/" + targetId.toString() + "/").length;
+//                         // const pathStartLight = path.substring(0, pathIndexLight);
+//                         targetProperty = path.substring(pathIndexLight);
+//                         switch (targetProperty) {
+//                             case "color":
+//                                 break;
+//                             case "intensity":
+//                                 break;
+//                         }
+//                         break;
+//                 }
+//                 if (path.includes("extensions/builtin_components"))
+//                     path = path.replace("extensions/builtin_components", "userData/components");
+//                 target.extensions[NEEDLE_KHR_ANIMATION_POINTER_NAME].path = path;
+//             }
+//             if (targetId === null) {
+//                 console.warn("Failed resolving animation node id: " + targetId, target);
+//                 continue;
+//             }
+//             // console.log("resolved name", targetId, type, targetProperty)
+//             let depPromise: any;
+//             if (type === TARGET_TYPE.node)
+//                 depPromise = this.parser.getDependency('node', targetId);
+//             else if (type === TARGET_TYPE.material)
+//                 depPromise = this.parser.getDependency('material', targetId);
+//             else if (type === TARGET_TYPE.light) {
+//                 // depPromise = this.parser.getDependency('light', targetId);
+//             }
+//             else
+//                 console.error("Unhandled type", type);
+//             pendingNodes.push(depPromise);
+//             pendingInputAccessors.push(this.parser.getDependency('accessor', input));
+//             pendingOutputAccessors.push(this.parser.getDependency('accessor', output));
+//             pendingSamplers.push(sampler);
+//             pendingTargets.push(target);
+//         }
+//         return Promise.all([
+//             Promise.all(pendingNodes),
+//             Promise.all(pendingInputAccessors),
+//             Promise.all(pendingOutputAccessors),
+//             Promise.all(pendingSamplers),
+//             Promise.all(pendingTargets),
+//         ]).then((dependencies) => {
+//             const nodes = dependencies[0];
+//             const inputAccessors = dependencies[1];
+//             const outputAccessors = dependencies[2];
+//             const samplers = dependencies[3];
+//             const targets = dependencies[4];
+//             const tracks: KeyframeTrack[] = [];
+//             for (let i = 0, il = nodes.length; i < il; i++) {
+//                 if (nodes[i] === undefined) continue; // unsupported types
+//                 const node = nodes[i];
+//                 const inputAccessor: BufferAttribute = inputAccessors[i];
+//                 const outputAccessor: BufferAttribute = outputAccessors[i];
+//                 const sampler = samplers[i];
+//                 const target: any = targets[i];
+//                 const ext = target.extensions;
+//                 let animatedPropertyPath = ext ? ext[NEEDLE_KHR_ANIMATION_POINTER_NAME]?.path : null;
+//                 if (animatedPropertyPath) {
+//                     animatedPropertyPath = animatedPropertyPath.replaceAll("/", ".");
+//                     // replace material ID by UUID
+//                     let parts = animatedPropertyPath.split('.');
+//                     node.sourceId = parts[2];
+//                     // parts[2] = node.uuid;
+//                     animatedPropertyPath = parts.join('.');
+//                     if (debug)
+//                         console.log(node, inputAccessor, outputAccessor, target, animatedPropertyPath);
+//                 }
+//                 if (node === undefined) continue;
+//                 if (node.updateMatrix) {
+//                     node.updateMatrix();
+//                     node.matrixAutoUpdate = true;
+//                 }
+//                 let TypedKeyframeTrack;
+//                 switch (PATH_PROPERTIES[target.path]) {
+//                     case PATH_PROPERTIES.weights:
+//                         TypedKeyframeTrack = NumberKeyframeTrack;
+//                         break;
+//                     case PATH_PROPERTIES.rotation:
+//                         TypedKeyframeTrack = QuaternionKeyframeTrack;
+//                         break;
+//                     case PATH_PROPERTIES.position:
+//                     case PATH_PROPERTIES.scale:
+//                         TypedKeyframeTrack = VectorKeyframeTrack;
+//                         break;
+//                     default:
+//                         switch (outputAccessor.itemSize) {
+//                             case 1:
+//                                 TypedKeyframeTrack = NumberKeyframeTrack;
+//                                 break;
+//                             case 2:
+//                             case 3:
+//                                 TypedKeyframeTrack = VectorKeyframeTrack;
+//                                 break;
+//                             case 4:
+//                                 TypedKeyframeTrack = ColorKeyframeTrack;
+//                                 break;
+//                         }
+//                         break;
+//                 }
+//                 const targetName = node.name ? node.name : node.uuid;
+//                 const interpolation = sampler.interpolation !== undefined ? INTERPOLATION[sampler.interpolation] : InterpolateLinear;
+//                 const targetNames: string[] = [];
+//                 if (PATH_PROPERTIES[target.path] === PATH_PROPERTIES.weights) {
+//                     node.traverse(function (object) {
+//                         if (object.morphTargetInfluences) {
+//                             targetNames.push(object.name ? object.name : object.uuid);
+//                         }
+//                     });
+//                 } else {
+//                     targetNames.push(targetName);
+//                 }
+//                 let outputArray = outputAccessor.array;
+//                 if (outputAccessor.normalized) {
+//                     // TODO: this function exists on GLTFLoader - we may be just able to call it from here
+//                     //@ts-ignore
+//                     const scale = getNormalizedComponentScale(outputArray.constructor);
+//                     const scaled = new Float32Array(outputArray.length);
+//                     for (let j = 0, jl = outputArray.length; j < jl; j++) {
+//                         scaled[j] = outputArray[j] * scale;
+//                     }
+//                     outputArray = scaled;
+//                 }
+//                 for (let j = 0, jl = targetNames.length; j < jl; j++) {
+//                     let targetPath = PATH_PROPERTIES[target.path];
+//                     const name = targetNames[j];
+//                     const trackName = animatedPropertyPath ?? (name + "." + targetPath);
+//                     console.log(trackName);
+//                     const track = new TypedKeyframeTrack(
+//                         trackName,
+//                         inputAccessor.array,
+//                         outputArray,
+//                         interpolation
+//                     );
+//                     // this is just to make animation component work in setup again (finding the correct gameObject)
+//                     track.__objectName = name;
+//                     // Override interpolation with custom factory method.
+//                     if (sampler.interpolation === 'CUBICSPLINE') {
+//                         console.warn("Cubic interpolation not supported for KHR_animation2 extension for now - TODO: copy from GLTFLoader")
+//                         // track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline(result) {
+//                         //     // A CUBICSPLINE keyframe in glTF has three output values for each input value,
+//                         //     // representing inTangent, splineVertex, and outTangent. As a result, track.getValueSize()
+//                         //     // must be divided by three to get the interpolant's sampleSize argument.
+//                         //     const interpolantType = (this instanceof QuaternionKeyframeTrack) ? GLTFCubicSplineQuaternionInterpolant : GLTFCubicSplineInterpolant;
+//                         //     return new interpolantType(this.times, this.values, this.getValueSize() / 3, result);
+//                         // };
+//                         // // Mark as CUBICSPLINE. `track.getInterpolation()` doesn't support custom interpolants.
+//                         // track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true;
+//                     }
+//                     tracks.push(track);
+//                 }
+//             }
+//             const name = animationDef.name ? animationDef.name : 'animation_' + animationIndex;
+//             const clip = new AnimationClip(name, undefined, tracks);
+//             return clip;
+//         });
+//     }
+//     private tryResolveNodeId(path: string, type: string): number | null {
+//         let name: string = "";
+//         if (type === "node") {
+//             name = path.substring("/nodes/".length);
+//         }
+//         else if (type === "material") {
+//             name = path.substring("/materials/".length);
+//         }
+//         name = name.substring(0, name.indexOf("/"));
+//         const index = Number.parseInt(name);
+//         return index;
+//     }
+//     // async afterRoot(result: GLTF): Promise<void> {
+//     //     const parser = result.parser;
+//     //     const ext = parser?.extensions;
+//     //     if (!ext) return;
+//     //     const hasExtension = ext[this.name];
+//     //     if (!hasExtension) return;
+//     //     if (result.animations?.length)
+//     //         console.log(result);
+//     //     if (hasExtension === true) {
+//     //         const data = parser.plugins[this.name];
+//     //         if (!data) return;
+//     //         const nodes = parser.json.nodes;
+//     //         // console.log(result);
+//     //         // for (let i = 0; i < nodes.length; i++) {
+//     //         //     const obj = await parser.getDependency('node', i);
+//     //         //     // this.nodeToObjectMap[i] = obj;
+//     //         // }
+//     //         for (let i = 0; i < nodes.length; i++) {
+//     //             const node = nodes[i];
+//     //             // console.log(node);
+//     //             // const index = i;
+//     //             const ext = node.extensions;
+//     //             if (!ext) continue;
+//     //             const data = ext[this.name];
+//     //             console.log(result);
+//     //             console.log(node, data);
+//     //         }
+//     //     }
+//     //     return;
+//     // }
+// }
+//# sourceMappingURL=KHR_animation_pointer.js.map

package/lib/engine/extensions/KHR_animation_pointer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KHR_animation_pointer.js","sourceRoot":"","sources":["../../../../engine/extensions/KHR_animation_pointer.ts"],"names":[],"mappings":"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"}

package/lib/engine/extensions/NEEDLE_animator_controller.js

@@ -0,0 +1,59 @@
+"use strict";
+// import { builtinComponentKeyName } from "../engine_constants";
+// import { AnimationClip, Object3D } from "three";
+// import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+// import { EXTENSION_NAME as COMPONENT_EXTENSION_NAME } from "./NEEDLE_components";
+// import { AnimatorConditionMode, AnimatorControllerModel } from "./NEEDLE_animator_controller_model";
+// export const EXTENSION_NAME = "NEEDLE_animator_controller";
+// export class NEEDLE_animator_controller implements GLTFLoaderPlugin {
+//     get name(): string {
+//         return EXTENSION_NAME;
+//     }
+//     private parser: GLTFParser;
+//     constructor(parser: GLTFParser) {
+//         this.parser = parser;
+//         // console.log(this);
+//     }
+//     // private lastIndex: number = -1;
+//     afterRoot(result: GLTF): Promise<void> | null {
+//         for (const node of this.parser.json.nodes) {
+//             if (!node.extensions) continue;
+//             const ext = node.extensions[EXTENSION_NAME];
+//             this.assignAnimationClips(result.animations, ext);
+//             const componentsExt = node.extensions[COMPONENT_EXTENSION_NAME];
+//             if (ext && componentsExt) {
+//                 console.log(ext, componentsExt);
+//                 for (const comp of componentsExt[builtinComponentKeyName]) {
+//                     if (typeof comp["runtimeAnimatorController"] === "object") {
+//                         const guid = comp["runtimeAnimatorController"].guid;
+//                         if (guid === ext.guid) {
+//                             comp["runtimeAnimatorController"] = ext;
+//                         }
+//                     }
+//                 }
+//             }
+//         }
+//         return null;
+//     }
+//     private assignAnimationClips(clips: AnimationClip[], ext : AnimatorControllerModel) {
+//         if (!clips || clips.length <= 0) return;
+//         if (!ext || !ext.layers) return;
+//         for (const layer of ext.layers) {
+//             const sm = layer?.stateMachine;
+//             if(!sm?.states) continue;
+//             for(const state of sm.states) {
+//                 const motion = state.motion;
+//                 if(motion?.index >= 0) {
+//                     const clip = clips[motion.index];
+//                     if(clip) {
+//                         state.motion.clip = clip;
+//                     }
+//                 }
+//             }
+//         }
+//     }
+//     // private applyExtensionData(node: Object3D, ext: TimelineData) {
+//     //     console.log(node, ext);
+//     // }
+// }
+//# sourceMappingURL=NEEDLE_animator_controller.js.map

package/lib/engine/extensions/NEEDLE_animator_controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NEEDLE_animator_controller.js","sourceRoot":"","sources":["../../../../engine/extensions/NEEDLE_animator_controller.ts"],"names":[],"mappings":";AAAA,iEAAiE;AACjE,mDAAmD;AACnD,8FAA8F;AAC9F,oFAAoF;AACpF,uGAAuG;AAEvG,8DAA8D;AAG9D,wEAAwE;AAExE,2BAA2B;AAC3B,iCAAiC;AACjC,QAAQ;AAER,kCAAkC;AAElC,wCAAwC;AACxC,gCAAgC;AAChC,gCAAgC;AAChC,QAAQ;AAER,yCAAyC;AACzC,sDAAsD;AACtD,uDAAuD;AACvD,8CAA8C;AAC9C,2DAA2D;AAC3D,iEAAiE;AACjE,+EAA+E;AAC/E,0CAA0C;AAC1C,mDAAmD;AACnD,+EAA+E;AAC/E,mFAAmF;AACnF,+EAA+E;AAC/E,mDAAmD;AACnD,uEAAuE;AACvE,4BAA4B;AAC5B,wBAAwB;AACxB,oBAAoB;AACpB,gBAAgB;AAChB,YAAY;AACZ,uBAAuB;AACvB,QAAQ;AAER,4FAA4F;AAC5F,mDAAmD;AACnD,2CAA2C;AAC3C,4CAA4C;AAC5C,8CAA8C;AAC9C,wCAAwC;AACxC,8CAA8C;AAC9C,+CAA+C;AAC/C,2CAA2C;AAC3C,wDAAwD;AACxD,iCAAiC;AACjC,oDAAoD;AACpD,wBAAwB;AACxB,oBAAoB;AACpB,gBAAgB;AAChB,YAAY;AACZ,QAAQ;AAER,yEAAyE;AAEzE,qCAAqC;AAErC,WAAW;AACX,IAAI"}

package/lib/engine/extensions/NEEDLE_animator_controller_model.d.ts

@@ -0,0 +1,108 @@
+import { Animator } from "../../engine-components/Animator";
+import { AnimationAction, AnimationClip, Object3D } from "three";
+import { Context } from "../engine_setup";
+import { InstantiateIdProvider } from "../../engine/engine_networking_instantiate";
+export declare type AnimatorControllerModel = {
+    name: string;
+    guid: string;
+    parameters: Parameter[];
+    layers: Layer[];
+};
+export declare type Parameter = {
+    name: string;
+    /** the animator string to hash result, test against this if a number is used to get a param value */
+    hash: number;
+    type: AnimatorControllerParameterType;
+    value: number | boolean | string;
+};
+export declare type Layer = {
+    name: string;
+    stateMachine: StateMachine;
+};
+export declare type StateMachine = {
+    defaultState: number;
+    states: State[];
+};
+export declare type State = {
+    name: string;
+    hash: number;
+    motion: Motion;
+    transitions: Transition[];
+    behaviours: StateMachineBehaviourModel[];
+};
+export declare type StateMachineBehaviourModel = {
+    typeName: string;
+    properties: object;
+    instance?: StateMachineBehaviour;
+};
+export declare abstract class StateMachineBehaviour {
+    _context?: Context;
+    get context(): Context;
+    get isStateMachineBehaviour(): boolean;
+    onStateEnter?(animator: Animator, _animatorStateInfo: AnimatorStateInfo, layerIndex: number): any;
+    onStateUpdate?(animator: Animator, animatorStateInfo: AnimatorStateInfo, _layerIndex: number): any;
+    onStateExit?(animator: Animator, animatorStateInfo: AnimatorStateInfo, layerIndex: number): any;
+}
+export declare class AnimatorStateInfo {
+    private _name;
+    get name(): string;
+    private _nameHash;
+    get nameHash(): number;
+    private _normalizedTime;
+    get normalizedTime(): number;
+    private _length;
+    get length(): number;
+    private _speed;
+    get speed(): number;
+    constructor(state: State, normalizedTime: number, length: number, speed: number);
+}
+export declare type Motion = {
+    name: string;
+    isLooping: boolean;
+    guid: string;
+    /** clip index in gltf animations array */
+    index: number;
+    /** the resolved clip */
+    clip?: AnimationClip;
+    /** the clip mapping -> which object has which animationclip */
+    clips?: ClipMapping[];
+    action?: AnimationAction;
+    /** used when a transition points to the same state we need another action to blend */
+    action_loopback?: AnimationAction;
+};
+export declare function createMotion(name: string, id?: InstantiateIdProvider): Motion;
+export declare type ClipMapping = {
+    /** the object this clip is for */
+    node: Object3D;
+    /** the animationclip we resolve from a json ptr */
+    clip: AnimationClip;
+};
+export declare type Transition = {
+    isExit: boolean;
+    exitTime: number;
+    hasFixedDuration: boolean;
+    offset: number;
+    duration: number;
+    hasExitTime: number;
+    destinationState: number | State;
+    conditions: Condition[];
+};
+export declare type Condition = {
+    parameter: string;
+    mode: AnimatorConditionMode;
+    threshold: number;
+};
+export declare enum AnimatorConditionMode {
+    If = 1,
+    IfNot = 2,
+    Greater = 3,
+    Less = 4,
+    Equals = 6,
+    NotEqual = 7
+}
+export declare enum AnimatorControllerParameterType {
+    Float = 1,
+    Int = 3,
+    Bool = 4,
+    Trigger = 9
+}