Home Reference Source

cables_dev/cables/src/core/anim.js

  1. import { Events, Logger } from "cables-shared-client";
  2. import { logStack, uuid } from "./utils.js";
  3. import { AnimKey } from "./anim_key.js";
  4. import { Op } from "./core_op.js";
  5. import { Port } from "./core_port.js";
  6. import { Patch } from "./core_patch.js";
  8. let counts = {};
  10. /**
  11.  * Keyframed interpolated animation.
  12.  *
  13.  * @class
  14.  * @param cfg
  15.  * @example
  16.  * var anim=new CABLES.Anim();
  17.  * anim.setValue(0,0);  // set value 0 at 0 seconds
  18.  * anim.setValue(10,1); // set value 1 at 10 seconds
  19.  * anim.getValue(5);    // get value at 5 seconds - this returns 0.5
  20.  */
  22. export class Anim extends Events
  23. {
  24.     static EVENT_KEY_DELETE = "keyDelete";
  25.     static EVENT_CHANGE = "onChange";
  26.     static EVENT_UIATTRIB_CHANGE = "uiattrchange";
  28.     static LOOP_OFF = 0;
  29.     static LOOP_REPEAT = 1;
  30.     static LOOP_MIRROR = 2;
  31.     static LOOP_OFFSET = 3;
  33.     static EASING_LINEAR = 0;
  34.     static EASING_ABSOLUTE = 1;
  35.     static EASING_SMOOTHSTEP = 2;
  36.     static EASING_SMOOTHERSTEP = 3;
  37.     static EASING_CUBICSPLINE = 4;
  39.     static EASING_CUBIC_IN = 5;
  40.     static EASING_CUBIC_OUT = 6;
  41.     static EASING_CUBIC_INOUT = 7;
  43.     static EASING_EXPO_IN = 8;
  44.     static EASING_EXPO_OUT = 9;
  45.     static EASING_EXPO_INOUT = 10;
  47.     static EASING_SIN_IN = 11;
  48.     static EASING_SIN_OUT = 12;
  49.     static EASING_SIN_INOUT = 13;
  51.     static EASING_BACK_IN = 14;
  52.     static EASING_BACK_OUT = 15;
  53.     static EASING_BACK_INOUT = 16;
  55.     static EASING_ELASTIC_IN = 17;
  56.     static EASING_ELASTIC_OUT = 18;
  58.     static EASING_BOUNCE_IN = 19;
  59.     static EASING_BOUNCE_OUT = 21;
  61.     static EASING_QUART_IN = 22;
  62.     static EASING_QUART_OUT = 23;
  63.     static EASING_QUART_INOUT = 24;
  65.     static EASING_QUINT_IN = 25;
  66.     static EASING_QUINT_OUT = 26;
  67.     static EASING_QUINT_INOUT = 27;
  69.     static EASING_CLIP = 28;
  71.     static EASINGNAMES = ["linear", "absolute", "smoothstep", "smootherstep", "Cubic In", "Cubic Out", "Cubic In Out", "Expo In", "Expo Out", "Expo In Out", "Sin In", "Sin Out", "Sin In Out", "Quart In", "Quart Out", "Quart In Out", "Quint In", "Quint Out", "Quint In Out", "Back In", "Back Out", "Back In Out", "Elastic In", "Elastic Out", "Bounce In", "Bounce Out", "Clip"];
  73.     #tlActive = true;
  74.     uiAttribs = {};
  75.     loop = 0;
  76.     onLooped = null;
  77.     _timesLooped = 0;
  78.     #needsSort = false;
  79.     _cachedIndex = 0;
  81.     /** @type {Port} */
  82.     port = null;
  84.     /** @type {AnimKey[]} */
  85.     keys = [];
  86.     onChange = null;
  87.     stayInTimeline = false;
  88.     batchMode = false;
  90.     /**
  91.      * @param {AnimCfg} [cfg]
  92.      */
  93.     constructor(cfg = {})
  94.     {
  95.         super();
  96.         cfg = cfg || {};
  97.         this.id = uuid();
  98.         this._log = new Logger("Anim");
  99.         this.name = cfg.name || null;
  101.         /** @type {Number} */
  102.         this.defaultEasing = cfg.defaultEasing || Anim.EASING_LINEAR;
  103.     }
  105.     forceChangeCallback()
  106.     {
  107.         if (this.onChange !== null) this.onChange();
  108.         this.emitEvent(Anim.EVENT_CHANGE, this);
  109.     }
  111.     forceChangeCallbackSoon()
  112.     {
  113.         if (this.batchMode) return;
  114.         if (!this.forcecbto)
  115.             this.forcecbto = setTimeout(() =>
  116.             {
  117.                 this.forceChangeCallback();
  118.                 this.forcecbto = null;
  119.             },
  120.             50);
  121.     }
  123.     getLoop()
  124.     {
  125.         return this.loop;
  126.     }
  128.     /**
  129.      * @param {number} loopType
  130.      */
  131.     setLoop(loopType)
  132.     {
  133.         if (loopType === false)loopType = 0;
  134.         if (loopType === true)loopType = 1;
  136.         this.loop = loopType;
  137.         this.emitEvent(Anim.EVENT_CHANGE, this);
  138.     }
  140.     /**
  141.      * returns true if animation has ended at @time
  142.      * checks if last key time is < time
  143.      * @param {Number} time
  144.      * @returns {Boolean}
  145.      * @memberof Anim
  146.      * @instance
  147.      * @function
  148.      */
  149.     hasEnded(time)
  150.     {
  151.         if (this.#needsSort) this.sortKeys();
  152.         if (this.keys.length === 0) return true;
  153.         if (this.keys[this.keys.length - 1].time <= time) return true;
  154.         return false;
  155.     }
  157.     /**
  158.      * @param {number} time
  159.      */
  160.     hasStarted(time)
  161.     {
  162.         if (this.#needsSort) this.sortKeys();
  163.         if (this.keys.length === 0) return false;
  164.         if (time >= this.keys[0].time) return true;
  165.         return false;
  166.     }
  168.     /**
  169.      * @param {number} time
  170.      */
  171.     isRising(time)
  172.     {
  173.         if (this.#needsSort) this.sortKeys();
  174.         if (this.hasEnded(time)) return false;
  175.         const ki = this.getKeyIndex(time);
  176.         if (this.keys[ki].value < this.keys[ki + 1].value) return true;
  177.         return false;
  178.     }
  180.     /**
  181.      * remove all keys from animation before time
  182.      * @param {Number} time
  183.      * @memberof Anim
  184.      * @instance
  185.      * @function
  186.      */
  187.     clearBefore(time)
  188.     {
  189.         if (this.#needsSort) this.sortKeys();
  190.         const v = this.getValue(time);
  191.         const ki = this.getKeyIndex(time);
  193.         this.setValue(time, v);
  195.         if (ki > 1)
  196.         {
  197.             this.keys.splice(0, ki);
  198.             this.#needsSort = true;
  199.         }
  200.     }
  202.     /**
  203.      * remove all keys from animation
  204.      * @param {Number} [time=0] set a new key at time with the old value at time
  205.      * @memberof Anim
  206.      * @instance
  207.      * @function
  208.      */
  209.     clear(time)
  210.     {
  211.         if (this.#needsSort) this.sortKeys();
  212.         let v = 0;
  213.         if (time) v = this.getValue(time);
  215.         for (let i = 0; i < this.keys.length; i++)
  216.             this.emitEvent(Anim.EVENT_KEY_DELETE, this.keys[i]);
  218.         this.keys.length = 0;
  219.         if (time) this.setValue(time, v);
  220.         this.#needsSort = true;
  221.         if (this.onChange !== null) this.onChange();
  222.         this.emitEvent(Anim.EVENT_CHANGE, this);
  223.     }
  225.     checkIsSorted()
  226.     {
  227.         let isSorted = true;
  228.         for (let i = 0; i < this.keys.length - 1; i++)
  229.             if (this.keys[i].time > this.keys[i + 1].time)
  230.             {
  231.                 isSorted = false;
  232.                 break;
  233.             }
  235.         return isSorted;
  236.     }
  238.     sortKeys()
  239.     {
  240.         if (this.batchMode) return;
  241.         if (!this.checkIsSorted())
  242.         {
  243.             this.keys.sort((a, b) => { return a.time - b.time; });
  244.             this.#needsSort = false;
  245.             if (this.keys.length > 999 && this.keys.length % 1000 == 0)console.log(this.name, this.keys.length);
  247.             this.emitEvent(Anim.EVENT_CHANGE);
  248.         }
  249.     }
  251.     hasDuplicates()
  252.     {
  253.         const test = {};
  254.         let count = 0;
  255.         for (let i = 0; i < this.keys.length; i++)
  256.         {
  257.             test[this.keys[i].time] = 1;
  258.             count++;
  259.         }
  261.         const keys = Object.keys(test);
  262.         if (keys.length != count)
  263.         {
  264.             return true;
  265.         }
  266.         return false;
  267.     }
  269.     removeDuplicates()
  270.     {
  271.         if (this.hasDuplicates())
  272.         {
  273.             if (this.#needsSort) this.sortKeys();
  274.             let count = 0;
  276.             while (this.hasDuplicates())
  277.             {
  278.                 for (let i = 0; i < this.keys.length - 1; i++)
  279.                 {
  280.                     if (this.keys[i].time == this.keys[i + 1].time)
  281.                     {
  282.                         const oldkey = this.keys[i];
  283.                         this.keys.splice(i, 1);
  284.                         this.emitEvent(Anim.EVENT_KEY_DELETE, oldkey);
  285.                     }
  286.                     count++;
  287.                 }
  288.             }
  289.             this.#needsSort = true;
  290.         }
  291.     }
  293.     getLengthLoop()
  294.     {
  295.         if (this.#needsSort) this.sortKeys();
  296.         if (this.keys.length < 2) return 0;
  297.         return this.lastKey.time - this.firstKey.time;
  298.     }
  300.     getLength()
  301.     {
  302.         if (this.#needsSort) this.sortKeys();
  303.         if (this.keys.length === 0) return 0;
  304.         return this.lastKey.time;
  305.     }
  307.     /**
  308.      * @param {number} time
  309.      */
  310.     getKeyIndex(time)
  311.     {
  312.         if (this.#needsSort) this.sortKeys();
  313.         let index = 0;
  314.         let start = 0;
  315.         if (this._cachedIndex && this.keys.length > this._cachedIndex && time >= this.keys[this._cachedIndex].time) start = this._cachedIndex;
  316.         for (let i = start; i < this.keys.length; i++)
  317.         {
  318.             if (time >= this.keys[i].time) index = i;
  319.             if (this.keys[i].time > time)
  320.             {
  321.                 if (time != 0) this._cachedIndex = index;
  322.                 return index;
  323.             }
  324.         }
  326.         return index;
  327.     }
  329.     /**
  330.      * set value at time
  331.      * @param {Number} time
  332.      * @param {Number} value
  333.      * @param {Function} cb callback
  334.      */
  335.     setValue(time, value, cb = null)
  336.     {
  337.         if (isNaN(value))CABLES.logStack();
  339.         if (this.#needsSort) this.sortKeys();
  340.         let found = null;
  342.         if (!this.batchMode)
  343.             if (this.keys.length == 0 || time <= this.lastKey.time)
  344.                 for (let i = 0; i < this.keys.length; i++)
  345.                     if (this.keys[i].time == time)
  346.                     {
  347.                         found = this.keys[i];
  348.                         this.keys[i].setValue(value);
  349.                         this.keys[i].cb = cb;
  350.                         break;
  351.                     }
  353.         if (!found)
  354.         {
  355.             found = new AnimKey(
  356.                 {
  357.                     "time": time,
  358.                     "value": value,
  359.                     "e": this.defaultEasing,
  360.                     "cb": cb,
  361.                     "anim": this
  362.                 });
  363.             this.keys.push(found);
  365.             // if (this.keys.length % 1000 == 0)console.log(this.name, this.keys.length);
  366.         }
  368.         if (!this.batchMode)
  369.         {
  371.             if (this.onChange) this.onChange();
  372.             this.emitEvent(Anim.EVENT_CHANGE, this);
  373.             this.#needsSort = true;
  374.         }
  375.         return found;
  376.     }
  378.     /**
  379.      * @param {number} index
  380.      * @param {number} easing
  381.      */
  382.     setKeyEasing(index, easing)
  383.     {
  384.         if (this.keys[index])
  385.         {
  386.             this.keys[index].setEasing(easing);
  387.             this.emitEvent(Anim.EVENT_CHANGE, this);
  388.         }
  389.     }
  391.     /**
  392.      * @param {object} obj
  393.      * @param {boolean} [clear]
  394.      * @param {object} [missingClipAnims]
  395.      */
  396.     deserialize(obj, clear, missingClipAnims)
  397.     {
  398.         if (obj.loop) this.loop = obj.loop;
  399.         if (obj.tlActive) this.#tlActive = obj.tlActive;
  400.         if (obj.height) this.uiAttribs.height = obj.height;
  401.         if (clear)
  402.         {
  403.             while (this.keys.length) this.keys[0].delete();
  405.             this.keys.length = 0;
  406.         }
  408.         for (const ani in obj.keys)
  409.         {
  410.             let newKey = new AnimKey(obj.keys[ani], this);
  411.             this.keys.push(newKey);
  412.             if (missingClipAnims)
  413.                 if (obj.keys[ani].clipId)
  414.                 {
  415.                     missingClipAnims[obj.keys[ani].clipId] = missingClipAnims[obj.keys[ani].clipId] || [];
  416.                     if (missingClipAnims)missingClipAnims[obj.keys[ani].clipId].push(newKey);
  417.                 }
  418.         }
  419.         this.sortKeys();
  420.     }
  422.     /**
  423.      * @returns {SerializedAnim}
  424.      */
  425.     getSerialized()
  426.     {
  428.         /** @type {SerializedAnim} */
  429.         const obj = {};
  430.         obj.keys = [];
  431.         obj.loop = this.loop;
  432.         if (this.#tlActive)obj.tlActive = this.tlActive;
  433.         if (this.uiAttribs.height)obj.height = this.uiAttribs.height;
  435.         for (let i = 0; i < this.keys.length; i++)
  436.             obj.keys.push(this.keys[i].getSerialized());
  438.         return obj;
  439.     }
  441.     /**
  442.      * @param {number} time
  443.      */
  444.     getKey(time)
  445.     {
  446.         if (this.#needsSort) this.sortKeys();
  447.         const index = this.getKeyIndex(time);
  448.         return this.keys[index];
  449.     }
  451.     /**
  452.      * @param {number} time
  453.      */
  454.     getNextKey(time)
  455.     {
  456.         if (this.#needsSort) this.sortKeys();
  457.         let index = this.getKeyIndex(time) + 1;
  458.         if (index >= this.keys.length) return null;
  460.         return this.keys[index];
  461.     }
  463.     /**
  464.      * @param {number} time
  465.      */
  466.     getPrevKey(time)
  467.     {
  468.         if (this.#needsSort) this.sortKeys();
  469.         let index = this.getKeyIndex(time) - 1;
  470.         if (index < 0) return null;
  472.         return this.keys[index];
  473.     }
  475.     /**
  476.      * @param {number} time
  477.      */
  478.     isFinished(time)
  479.     {
  480.         if (this.#needsSort) this.sortKeys();
  481.         if (this.keys.length <= 0) return true;
  482.         return time > this.lastKey.time;
  483.     }
  485.     /**
  486.      * @param {number} time
  487.      */
  488.     isStarted(time)
  489.     {
  490.         if (this.#needsSort) this.sortKeys();
  491.         if (this.keys.length <= 0) return false;
  492.         return time >= this.firstKey.time;
  493.     }
  495.     /**
  496.      * @param {AnimKey} k
  497.      * @param {undefined} [events]
  498.      */
  499.     remove(k, events)
  500.     {
  501.         for (let i = 0; i < this.keys.length; i++)
  502.         {
  503.             if (this.keys[i] == k)
  504.             {
  505.                 this.emitEvent(Anim.EVENT_KEY_DELETE, this.keys[i]);
  506.                 this.keys.splice(i, 1);
  507.                 this.#needsSort = true;
  508.                 if (events === undefined)
  509.                 {
  510.                     this.emitEvent(Anim.EVENT_CHANGE, this);
  511.                 }
  512.                 return;
  513.             }
  514.         }
  515.     }
  517.     get lastKey()
  518.     {
  519.         if (this.#needsSort) this.sortKeys();
  520.         return this.keys[this.keys.length - 1];
  521.     }
  523.     get firstKey()
  524.     {
  525.         if (this.#needsSort) this.sortKeys();
  526.         return this.keys[0];
  527.     }
  529.     /**
  530.      * @param {number} time
  531.      */
  532.     getLoopIndex(time)
  533.     {
  534.         if (this.#needsSort) this.sortKeys();
  535.         if (this.keys.length < 2) return 0;
  536.         return (time - this.firstKey.time) / this.getLengthLoop();
  537.     }
  539.     /**
  540.      * get value at time
  541.      * @function getValue
  542.      * @memberof Anim
  543.      * @instance
  544.      * @param {Number} [time] time
  545.      * @returns {Number} interpolated value at time
  546.      */
  547.     getValue(time = 0)
  548.     {
  549.         // if (isNaN(time))time = 0;
  550.         // counts[this.name] = counts[this.name] || 0;
  551.         // if (counts[this.name] < 10 && this.port)
  552.         // {
  553.         //     console.log("getvalue", this.name, time, this);
  554.         //     CABLES.logStack();
  555.         //     counts[this.name]++;
  556.         // }
  558.         let valAdd = 0;
  559.         if (this.keys.length === 0) return 0;
  560.         if (this.#needsSort) this.sortKeys();
  562.         if (!this.loop && time > this.lastKey.time)
  563.         {
  564.             if (this.lastKey.cb && !this.lastKey.cbTriggered) this.lastKey.trigger();
  566.             return this.lastKey.value;
  567.         }
  569.         if (time < this.firstKey.time) return this.keys[0].value;
  571.         if (this.loop && this.keys.length > 1 && time > this.lastKey.time)
  572.         {
  573.             const currentLoop = this.getLoopIndex(time);
  574.             if (currentLoop > this._timesLooped)
  575.             {
  576.                 this._timesLooped++;
  577.                 if (this.onLooped) this.onLooped();
  578.             }
  580.             time = (time - this.firstKey.time) % (this.getLengthLoop());
  582.             if (this.loop == Anim.LOOP_REPEAT) { }
  583.             else if (this.loop == Anim.LOOP_MIRROR)
  584.             {
  585.                 if (Math.floor(currentLoop) % 2 == 1)time = this.getLengthLoop() - time;
  586.             }
  587.             else if (this.loop == Anim.LOOP_OFFSET)
  588.             {
  589.                 valAdd = (this.lastKey.value - this.keys[0].value) * Math.floor(currentLoop);
  590.             }
  592.             time += this.firstKey.time;
  593.         }
  595.         const index = this.getKeyIndex(time);
  596.         if (index >= this.keys.length - 1)
  597.         {
  598.             if (this.lastKey.cb && !this.lastKey.cbTriggered) this.lastKey.trigger();
  599.             return this.lastKey.value;
  600.         }
  602.         const index2 = index + 1;
  603.         const key1 = this.keys[index];
  604.         const key2 = this.keys[index2];
  606.         if (key1.cb && !key1.cbTriggered) key1.trigger();
  608.         if (!key2) return -1;
  610.         const perc = (time - key1.time) / (key2.time - key1.time);
  612.         if (key1.getEasing() == Anim.EASING_CLIP)
  613.         {
  614.             if (!key1.clip && this.port)
  615.             {
  617.                 const patch = this.port.op.patch;
  618.                 const clip = patch.getVar(key1.clipId)?.getValue();
  619.                 if (clip) key1.clip = clip;
  620.             }
  621.             if (key1.clip && key1.clip.getValue)
  622.             {
  623.                 return key1.clip.getValue(perc * key1.clip.getLength());
  624.             }
  625.             else
  626.             {
  627.                 console.log("no clip found");
  628.             }
  629.         }
  631.         return key1.ease(perc, key2) + valAdd;
  632.     }
  634.     /**
  635.      * @param {AnimKey} k
  636.      */
  637.     addKey(k)
  638.     {
  639.         if (k.time === undefined)
  640.         {
  641.             this._log.warn("key time undefined, ignoring!");
  642.         }
  643.         else
  644.         {
  645.             this.keys.push(k);
  646.             if (this.onChange !== null) this.onChange();
  647.             this.emitEvent(Anim.EVENT_CHANGE, this);
  648.             this.#needsSort = true;
  649.         }
  650.     }
  652.     sortSoon()
  653.     {
  654.         this.#needsSort = true;
  655.     }
  657.     /**
  658.      * @param {string} str
  659.      */
  660.     easingFromString(str)
  661.     {
  662.         // todo smarter way to map ?
  663.         if (str == "linear") return Anim.EASING_LINEAR;
  664.         if (str == "absolute") return Anim.EASING_ABSOLUTE;
  665.         if (str == "smoothstep") return Anim.EASING_SMOOTHSTEP;
  666.         if (str == "smootherstep") return Anim.EASING_SMOOTHERSTEP;
  668.         if (str == "Cubic In") return Anim.EASING_CUBIC_IN;
  669.         if (str == "Cubic Out") return Anim.EASING_CUBIC_OUT;
  670.         if (str == "Cubic In Out") return Anim.EASING_CUBIC_INOUT;
  672.         if (str == "Expo In") return Anim.EASING_EXPO_IN;
  673.         if (str == "Expo Out") return Anim.EASING_EXPO_OUT;
  674.         if (str == "Expo In Out") return Anim.EASING_EXPO_INOUT;
  676.         if (str == "Sin In") return Anim.EASING_SIN_IN;
  677.         if (str == "Sin Out") return Anim.EASING_SIN_OUT;
  678.         if (str == "Sin In Out") return Anim.EASING_SIN_INOUT;
  680.         if (str == "Back In") return Anim.EASING_BACK_IN;
  681.         if (str == "Back Out") return Anim.EASING_BACK_OUT;
  682.         if (str == "Back In Out") return Anim.EASING_BACK_INOUT;
  684.         if (str == "Elastic In") return Anim.EASING_ELASTIC_IN;
  685.         if (str == "Elastic Out") return Anim.EASING_ELASTIC_OUT;
  687.         if (str == "Bounce In") return Anim.EASING_BOUNCE_IN;
  688.         if (str == "Bounce Out") return Anim.EASING_BOUNCE_OUT;
  690.         if (str == "Quart Out") return Anim.EASING_QUART_OUT;
  691.         if (str == "Quart In") return Anim.EASING_QUART_IN;
  692.         if (str == "Quart In Out") return Anim.EASING_QUART_INOUT;
  694.         if (str == "Quint Out") return Anim.EASING_QUINT_OUT;
  695.         if (str == "Quint In") return Anim.EASING_QUINT_IN;
  696.         if (str == "Quint In Out") return Anim.EASING_QUINT_INOUT;
  698.         console.log("unknown anim easing?", str);
  699.     }
  701.     /**
  702.      * @param {Op} op
  703.      * @param {string} title
  704.      * @param {function} cb
  705.      * @returns {Port}
  706.      */
  707.     createPort(op, title, cb)
  708.     {
  709.         const port = op.inDropDown(title, Anim.EASINGNAMES, "linear");
  710.         port.set("linear");
  711.         port.defaultValue = 0;
  713.         port.onChange = () =>
  714.         {
  715.             this.defaultEasing = this.easingFromString(port.get());
  716.             this.emitEvent("onChangeDefaultEasing", this);
  718.             if (cb) cb();
  719.         };
  721.         return port;
  722.     }
  724.     get tlActive()
  725.     {
  726.         return this.#tlActive;
  727.     }
  729.     set tlActive(b)
  730.     {
  731.         if (CABLES.UI)
  732.         {
  733.             this.#tlActive = b;
  734.             window.gui.emitEvent("tlActiveChanged", this);
  735.             this.forceChangeCallbackSoon();
  736.         }
  737.     }
  739.     /**
  740.      * @param {Object} o
  741.      */
  742.     setUiAttribs(o)
  743.     {
  744.         for (const i in o)
  745.         {
  746.             this.uiAttribs[i] = o[i];
  747.             if (o[i] === null) delete this.uiAttribs[i];
  748.         }
  750.         this.emitEvent(Anim.EVENT_UIATTRIB_CHANGE);
  751.     }
  753.     /**
  754.      * @param {number} t
  755.      * @param {number} t2
  756.      */
  757.     hasKeyframesBetween(t, t2)
  758.     {
  759.         for (let i = 0; i < this.keys.length; i++)
  760.             if (this.keys[i].time >= t && this.keys[i].time <= t2) return true;
  762.         return false;
  763.     }
  765.     /**
  766.      * @param {Patch} patch
  767.      */
  768.     static initClipsFromVars(patch)
  769.     {
  770.         for (const i in patch.missingClipAnims)
  771.         {
  773.             const v = patch.getVar(i);
  775.             for (let j = 0; j < patch.missingClipAnims[i].length; j++)
  776.             {
  777.                 patch.missingClipAnims[i].clip = v.getValue();
  778.                 delete patch.missingClipAnims[i];
  779.             }
  781.         }
  783.     }
  784. }