Repository: three.js
Issue: AnimationMixer.update() doesn't update tracks that did not change since last update(), even if they changed externally
Labels: Needs Investigation

### Description

AnimationMixer.update(delta) does not update bones which did not change in the animation, even if they _did_ change outside of it. This is inconsistent with the override behaviour of tracked properties exhibited normally. 

I am using Skeleton.pose() to reset all the bones to their original position.
Then I'm calling AnimationMixer.update(delta) to apply my animation.
The animation is not additive.
Doing this updates only the bones where the Interpolant's value has changed since. If you use an animation with a single holding frame, it will never set the armature to that holding frame, because it's the same frame as the previous one.
This behaviour is very unexpected, and leads to obscure bugs, like the one I initially opened this issue for. 

### Reproduction steps

1.Run fiddle. The left object's animation is a single holding frame, rotated to the left. Instead, it stays locked in the Skeleton.pose() position. The right bone has a single duplicate frame. Each time it encounters it, it doesn't update the Skeleton.pose() position, and displays that instead of the animation, which we update right after.
2.Remove the "skeletons.forEach(v=>v.pose());" and watch it work fine.


### Code

```js
let animatio_clip;
let animation_action;
let mixer;
let skeletons = [];

const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera();
scene.add(camera);
camera.translateZ(2)
camera.translateY(0.8);

const renderer = new THREE.WebGLRenderer();
renderer.setSize(window.innerWidth, window.innerHeight);
document.body.appendChild(renderer.domElement);


const light = new THREE.AmbientLight(0xFFFFFF);
light.intensity = 1;
scene.add(light);

new THREE.GLTFLoader().load(
    './BugBones.gltf',
    // called when the resource is loaded
    (gltf) =>
    {
        console.log("Loaded ", gltf)
        scene.add(gltf.scene)

        mixer = new THREE.AnimationMixer(scene);

        gltf.animations.forEach((clip) =>
        {
            animatio_clip = clip;
            animation_action = mixer.clipAction(clip);
            animation_action.loop = true;
            animation_action.play();
        });

        gltf.scene.traverse(o=>{
            if(o instanceof THREE.SkinnedMesh)
            {
                skeletons.push(o.skeleton);
            }
        })
        
    },
    // called while loading is progressing
    (xhr) => { },
    // called when loading has errors
    (error) =>
    {
        console.log('An error happened');
        console.error(error);
    }
);

let prev_time = Date.now();
function animate()
{
    let time = Date.now();
    skeletons.forEach(v=>v.pose());
    mixer?.update((time-prev_time)/1000)
    prev_time = time;
    renderer.render(scene, camera);
    requestAnimationFrame(animate);
}
animate();
```


### Live example

https://jsfiddle.net/5xsfez8r/

### Version

r128,r149

### Device

Desktop

### Browser

Chrome, Firefox

### OS

Linux