colinbdclark / aconite Goto Github PK

At the moment, Aconite lacks unit tests. It has a few tests that can be run manually and verified by eye, but none that run automatically.

Currently, the aconite.animationClock.frameCounter component's avgDuration() invoker calculates the average duration incorrectly. Since tickCounter is a zero-based index, it should calculate the average like this;

sum / tickCounter + 1;

I can't quite explain what's changed, but it seems that the clip sequencer manual test is no longer working properly. It's worth investigating what has changed, and also consider the possibility of avoiding the use of Video.currentTime for synchronization, since it appears that it isn't frame accurate. Instead, we should synchronize a manual frame counter with the resolution of the video elements's play() and pause() promises.

At the moment, Aconite is hard-coded to support a maximum of two compositable layers. Support additional layers, today, would require reimplementing quite a lot of internal infrastructure.

Instead, Aconite's main drawing loop should be eventized, so that any number of compositable layers can be supported.

Currently, the texture unit used by aconite.texture and within aconite.compositable.draw is specified as a component option. It should be moved into the model so that it can be specified by clients as the result of a model transformation, or more easily modulated (say, when reordering layers in an application.

The aconite.animationClock.frameCounter component throws an error whenever its maxDuration() invoker is called. This is due to the fact that it binds to the old DSP API, whereas Flocking upgraded to the newer WebArrayMath spec quite a while ago.

We should update all code DSP global references to ArrayMath.

By default, Aconite automatically mutes all videos and provides no means to control their volume. We add a model value bound to the media element's volume property, which should default to 0.0, and flip the muted default to false so audio volume can be easily changed on the fly.

In various spots, Aconite uses Infusion's event injection pattern, like:

gradeNames: "a.component"
events: {
    myEvent: "{otherComponent}.events.theirEvent"
}

Instead, unless actual event sharing is needed, it should use "event listener chaining," where a listener for the other component's event will fire the local component's event.

A video can be assumed to not yet be ready to play whenever:

• It is first created
• Its url model property changes

When its onVideoLoaded event fires (bound to canplaythrough), it is fully ready.

We should reflect this state as a boolean property (canPlayThrough, perhaps) in the aconite.video component's model.

A new dev release of Flocking has been cut, which removes Node.js support—this should make installing Aconite much faster. As always, we're behind on Infusion dev releases and there are vulnerabilities reported in older versions of Grunt and its plugins. Time for the usual round of updates.

Currently, aconite.clipSequencer has a sequencer subcomponent that still uses Flocking's older, worker-based scheduler. Since Aconite already uses Bergson throughout, it should be updated to use the Bergson scheduler instead.

It appears that HTML media elements that use time fragments cannot be looped. They will automatically pause themselves. Attempting to start them again with a call to play() will cause them to play past the time fragment's end point. So they're really only effective if you never want to loop your clips.

This behaviour is consistent across (at least) Chrome, Safari, and Firefox on my Mac. I assume it's in the spec, but haven't yet checked.

It seems that, instead, the aconite.clipSequencer needs to manage the currentTime property of the media element itself and schedule looping using its own Bergson scheduler at the appropriate interval.

At the moment, it's pretty awkward to work with Aconite shaders. They are somewhat hidden behind the aconite.glRenderer interface, which requires odd additional options for uniforms in addition to a model, as well as layers of wrapping of arrays that is confusing and error prone. Some useful comments about the issues can be found in Aconite's source code as well as the video example that was created for an older version of our Onward paper.

We should introduce a somewhat closer to the metal component that represents a GL shader and that is fully modelized, and which is responsible for loading (via a separate component), compiling, and attaching shaders as well as managing their runtime state.

There are new versions of Infusion, jQuery, Testem, and other dependencies. We should update and cut a maintenance release.

Aconite's play button overlay CSS is hardcoded to particular pixel offset that isn't particularly nice looking. It should be more responsive.