MadButterfly: nodejs/animate.js comparison

comparison nodejs/animate.js @ 906:62ef69e02e85

branch merge

author	Shih-Yuan Lee (FourDollars) <fourdollars@gmail.com>
date	Sun, 03 Oct 2010 18:15:00 +0800
parents	f4fd7a16361d
children	55767e444436

comparison

equal deleted inserted replaced

-:e3a5e05f00c1
+:62ef69e02e85
 * machines, ffs can be decreased or increased respective.
 */
 var ffs = 12;
 var frame_interval = 1000 / ffs;
-function linear_draw() {
+function shift_draw(percent) {
-var percent;
+var x, y;
-percent = (Date.now() - this._start_tm) / this.duration;
+x = (this.targetx - this.startposx) * percent + this.startposx;
-if(percent >= 1) {
+y = (this.targety - this.startposy) * percent + this.startposy;
-	percent = 1;
+this.obj.center.move(x, y);
-if (this.obj.timer) {
-	    this.obj.timer.stop();
-	    delete this.obj.timer;
-	}
-}
-this.obj.x = (this.targetx-this.startposx)*percent+this.startposx;
-this.obj.y = (this.targety-this.startposy)*percent+this.startposy;
 this.app.refresh();
 }
-function linear_draw_start() {
+function shift(app,obj,shiftx,shifty) {
-var obj = this.obj;
+obj.animated_shift = this;
-var self = this;
-if(obj.timer)
-	obj.timer.stop();
-this._start_tm = Date.now();
-obj.timer = setInterval(function() { self.draw(); }, frame_interval);
-}
-function linear(app,obj,shiftx,shifty,duration) {
-obj.animated_linear = this;
 this.app = app;
 this.obj = obj;
 this.end = 0;
-this.targetx = shiftx + obj.x;
+this.targetx = shiftx + obj.center.x;
-this.targety = shifty + obj.y;
+this.targety = shifty + obj.center.y;
-this.startposx = obj.x;
+this.startposx = obj.center.x;
-this.startposy = obj.y;
+this.startposy = obj.center.y;
-this.duration = duration*1000;
+}
-}
+exports.shift = shift;
-exports.linear = linear;
+shift.prototype.draw = shift_draw;
-linear.prototype.start = linear_draw_start;
-linear.prototype.draw = linear_draw;
 /* ------------------------------------------------------------ */
 function rotate(app, obj, ang, duration) {
 this._app = app;
 this._obj = obj;
 this._ang = ang;
-this._duration = duration * 1000;
-}
-function rotate_start() {
-var obj = this._obj;
-var self = this;
 this._start_mtx = [obj[0], obj[1], obj[2], obj[3], obj[4], obj[5]];
-this._start_tm = Date.now();
+}
-obj.timer = setInterval(function() { self.draw(); }, frame_interval);
-}
+function rotate_draw(percent) {
-function rotate_draw() {
 var percent;
 var ang;
 var sv, cv;
 var obj = this._obj;
 var mtx, shift;
-percent = (Date.now() - this._start_tm) / this._duration;
-if(percent >= 1) {
-	percent = 1;
-	obj.timer.stop();
-}
 ang = percent * this._ang;
 sv = Math.sin(ang);
 cv = Math.cos(ang);
 mtx = [cv, -sv, 0, sv, cv, 0];
+sys.puts('x='+obj.center.x+',y='+obj.center.y);
 shift = [1, 0, -obj.center.x, 0, 1, -obj.center.y];
 mtx = multiply(mtx, shift);
 shift = [1, 0, obj.center.x, 0, 1, obj.center.y];
 mtx = multiply(shift, mtx);
 mtx = multiply(mtx, this._start_mtx);
 obj[5] = mtx[5];
 this._app.refresh();
 }
-rotate.prototype.start = rotate_start;
 rotate.prototype.draw = rotate_draw;
 exports.rotate = rotate;
 function multiply(s,d) {
 var m=[];
 m[5] = s[3]*d[2]+s[4]*d[5]+s[5];
 return m;
 }
-function scale_draw() {
+function scale_draw(percent) {
-if (this.end == 1) return;
+var sx = 1 + (this.totalsx - 1) * percent;
-var percent = (Date.now() - this.starttime)/this.duration;
+var sy = 1 + (this.totalsy - 1) * percent;
-if (percent > 1) percent = 1;
+var sh1 = [1, 0, -this.center_x, 0, 1, -this.center_y];
-var sx = (this.targetx-this.startsx)*percent+this.startsx;
+var sh2 = [1, 0, this.center_x, 0, 1, this.center_y];
-var sy = (this.targety-this.startsy)*percent+this.startsy;
+var scale = [sx, 0, 0, 0, sy, 0];
-var t=[sx,0,0,0,sy,0];
+var obj = this.obj;
-this.obj[0] = sx;
+var mtx;
-this.obj[4] = sy;
-this.obj[2] = this.origin_offset_x - (sx-this.startsx)*this.obj.center.x;
+mtx = multiply(scale, sh1);
-this.obj[5] = this.origin_offset_y - (sy-this.startsy)*this.obj.center.y;
+mtx = multiply(sh2, mtx);
+mtx = multiply(this.orig_mtx, mtx);
+obj[0] = mtx[0];
+obj[1] = mtx[1];
+obj[2] = mtx[2];
+obj[3] = mtx[3];
+obj[4] = mtx[4];
+obj[5] = mtx[5];
 this.app.refresh();
-var self = this;
+}
-if (percent < 1) {
-	this.obj.timer=setTimeout(function() { self.draw();}, frame_interval);
+function scale(app, obj, fact_x, fact_y, duration) {
-	return;
+var bbox;
-}
-this.app.refresh();
-this.obj.animated_scale = null;
-}
-function scale(app,obj,targetx,targety, duration) {
 try {
 if (obj.animated_scale) {
-	    //obj[0] = obj.animated_scale.targetx;
-	    //obj[4] = obj.animated_scale.targety;
-	    //obj[2] = obj.animated_scale.final_offset_x;
-	    //obj[5] = obj.aninated_scale.final_offset_y;
 	    obj.animated_scale.end = 1;
 	}
 } catch(e) {
 }
+bbox = obj.bbox;
+bbox.update();
 obj.animated_scale = this;
 this.app = app;
 this.obj = obj;
 this.end = 0;
 this.starttime = Date.now();
-this.startsx = obj[0];
+this.totalsx = fact_x * bbox.orig.width / bbox.width;
-this.startsy = obj[4];
+this.totalsy = fact_y * bbox.orig.height / bbox.height;
-this.targetx = targetx;
-this.targety = targety;
 this.duration = duration*1000;
-this.origin_offset_x = obj[2];
+this.center_x = obj.center.rel.x;
-this.origin_offset_y = obj[5];
+this.center_y = obj.center.rel.y;
-this.final_offset_x = this.origin_offset_x-(targetx-this.startsx)*obj.center.x;
+this.orig_mtx = [obj[0], obj[1], obj[2], obj[3], obj[4], obj[5]];
-this.final_offset_y = this.origin_offset_y-(targety-this.startsy)*obj.center.y;
 }
 exports.scale = scale;
-scale.prototype.start = scale_draw;
 scale.prototype.draw = scale_draw;
 function holder(app, coord) {
 var mtx = [coord[0], coord[1], coord[2], coord[3], coord[4], coord[5]];
 exports.holder = holder;
-function alpha_draw() {
+function alpha_draw(percent) {
 if (this.end == 1) return;
-var percent = (Date.now() - this.starttime)/this.duration;
-if (percent > 1) percent = 1;
 var sx = (this.targetalpha-this.startalpha)*percent+this.startalpha;
 this.obj.opacity=sx;
-this.app.refresh();
-var self = this;
-if (percent < 1) {
-	this.obj.timer=setTimeout(function() { self.draw();}, frame_interval);
-	return;
-}
 this.app.refresh();
 this.obj.animated_alpha = null;
 }
 function alpha(app,obj,alpha, duration) {
 this.startalpha = obj.opacity;
 this.targetalpha = alpha;
 this.duration = duration*1000;
 }
-alpha.prototype.start = alpha_draw;
 alpha.prototype.draw = alpha_draw;
 exports.alpha = alpha;
+function linear_update()
+{
+var now = Date.now();
+var i;
+sys.puts("real time is "+now);
+sys.puts("end is "+this.end);
+if (now >= this.end) {
+this.timer.stop();
+	now = this.end;
+}
+if (now < this.startmove) return;
+sys.puts("now is "+now+" offset is "+(now-this.startmove));
+var per = (now-this.startmove)/this.duration/1000;
+if (per > 1) per = 1;
+this.action.draw(per);
+}
+function linear_start()
+{
+var self = this;
+if (this.timer)
+this.timer.stop();
+this.timer = setInterval(function() { self.update();}, frame_interval);
+this.startmove = Date.now()+this.starttime*1000;
+this.end = this.startmove+this.duration*1000;
+}
+function linear_stop()
+{
+if (this.timer) {
+this.timer.stop();
+	this.timer = null;
+}
+}
+function linear_finish()
+{
+this.action.draw(1);
+}
+function linear(action,start, duration)
+{
+this.action = action;
+this.duration = duration;
+this.starttime = start;
+this.timer=null;
+}
+linear.prototype.update = linear_update;
+linear.prototype.start = linear_start;
+linear.prototype.stop = linear_stop;
+linear.prototype.finish = linear_finish;
+exports.linear = linear;
+/* Following functions is not defined completed.
+Mark it out to prevent error message.
+function multilinear(action,start,stages) {
+sys.puts("Multilinear word is not implemented yet");
+}
+exports.multilinear = multilinear;
+multilinear.prototype.update = multilinear_update;
+multilinear.prototype.start = multilinear_start;
+multilinear.prototype.stop = multilinear_stop;
+multilinear.prototype.finish = multilinear_finish;
+function exponential(action,start,stages) {
+sys.puts("exponential word is not implemented yet");
+}
+exports.exponential = exponential;
+exponential.prototype.update = exponential_update;
+exponential.prototype.start = exponential_start;
+exponential.prototype.stop = exponential_stop;
+exponential.prototype.finish = exponential_finish;
+*/
+function program(words)
+{
+this.words = wrods;
+}
+program.prototype.start=function() {
+for(w in this.words) {
+w.start();
+}
+}
+program.prototype.step=function(s) {
+sys.puts("This function is not implemented yet");
+}
+program.prototype.stop=function() {
+for(w in this.words) {
+w.stop();
+}
+}
+program.prototype.finish=function() {
+for(w in this.words) {
+w.finish();
+}
+}
+exports.run = function(actions,start,duration) {
+for(a in actions) {
+var li = new linear(actions[a],start,duration);
+	sys.puts(li);
+	li.start();
+}
+}
+exports.runexp=function(actions,start,exp) {
+sys.puts("This function is not implemented yet");
+}