I found it necessary to create a list of elements that will be transformed during the animation. Within each list of elements there will be a sublist of transform types. Within each list of transform types there will be a list of the actual transforms. Element zero of the first two dimensions of the array will contain the name of the element and transform type, respectively.
The first set of calls should be to define the transforms as the programmers thinks of them. Once all the transforms are defined the code sweeps through the list and, where it finds multiple transforms of a specific type for a specific element, reorders that list of transforms by starting time.
I’m assuming that later transforms (in list of like transforms for a given element) will determine the state of the element from their beginning in time through to the end of the animation. It will not be possible to embed transformation streams. For example, if stream A runs from 3.0 seconds to 9.0 seconds and stream B runs from 5.0 seconds to 7.0 seconds, the states defined by stream B will apply from 5.0 seconds to the end of the animation. The animation will not use the values from stream A from 7.0 to 9.0 seconds. There has to be a rule and this is the one I’m choosing. It has the virtue of being simple while also allowing anything to be done at any time.
The code will look something like this. I haven’t got time to debug it today; that will be tomorrow’s project and I’ll post any mods I make then (the chances of this being perfect as is are somewhere between zero and nothing…). Once I know this works I can readjust the previously existing functions to write out the transformation streams.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 |
//add transforms to the list //add similar transforms of a given type for a given element to the existing lists function addTransformToList(sElement,sType,pStart,pEnd,tBegin,tEnd,mMethod) { //this object type stores the info needed to define the animation stream var obj = { pStart: pStart; pEnd: pEnd; tBegin: tBegin; tEnd: tEnd; mMethod: mMethod. } //element if (bcTransformList.length > 0) { var i = 0; while (i < bcTransformList.length) { if (sElement == bcTransformList[i][0]) { //element 0 has name of element break; } i++; } //transform type, don't have to check for empty type list if (i < bcTransformList.length) { //element already in list, add to it var j = 0; while (j < bcTransformList[i].length) { if (sType == bcTransformList[i][j][0]) { //element 0 has transform type break; } j++; } if (j < bcTransformList[i][j].length) { //type already in list, add object to existing sublist bcTransformList[i][j].push(obj); } else { //type not already in list, add it bcTransformList[i][j] = new Array; bcTransformList[i][j][0] = sType; bcTransformList[i][j][1] = obj; //element 1 and thereafter has actual transforms } } else { //element new to list, add to end bcTransformList[i] = new Array; bcTransformList[i][0] = sElement; bcTransformList[i][1] = new Array; bcTransformList[i][1][0] = sType; bcTransformList[i][1][1] = obj; } } else { //this is the first element bcTransformList[0] = new Array; bcTransformList[0][0] = sElement; bcTransformList[0][1] = new Array; bcTransformList[0][1][0] = sType; bcTransformList[0][1][1] = obj; } } //reorder by start time when multiple transforms of a given type exist for a given element function orderTransformList() { if (bcTransformList.length > 0) { for (var i=0; i<bcTransformList.length; i++) { //for each element for (var j=0; j<bcTransformList[i].length; j++) { //for each type if (bcTransformList[i][j].length > 2) { //if there are multiple elements, sort them var tempObj = new Array; tempObj[0] = bcTransformList[i][j][0]; //type tempObj[1] = bcTransformList[i][j][1]; //first element for (var k=2; k<bcTransformList[i][j].length; k++) { var n = 0; while (bcTransformList[i][j][k].tBegin >= tempObj[n].tBegin) { n++; } tempObj.splice(n+1,0,bcTransformList[i][j][k]); //subsequent elements, in order } bcTransformList[i][j] = tempObj; } } } } } |
Once I get this working it should enable me to come up with a better way to specify starting times for each transformation stream. The Greensock product allows the programmer to specify starting times relative to other events and not necessarily in absolute terms, which (as they point out here) is cumbersome to keep track of and modify efficiently. The product also supports a flexible, shorthand notation for specifying transformations of increasing complexity, assuming default values for parameters not supplied. It appears to do this using function parameters in something like the object literal format.