Pimp aM's Impulse

[ms_hh]

Guten Abend,

ich hatte am Dienstag eine Idee. Nachdem ich mir aM's Impulse Klasse angeschaut habe, kam mir die Idee. Ein "globales" onEnterFrame. Also machte ich mich an die Arbeit. Meine

Impulseklasse sollte folgendes können:
- pause/resume
- dispose
- setFrameRate

Als Logic für die ganze Geschichte, habe ich einen ImpulseHandler geschrieben (Singleton). Diese Klasse "enthält" das ware onEnterFrame. Die ImpulseInstanz "registriert" sich nun bei diesem Handler und fügt die Referenz der ImpulseInstanz in eine Liste ein. Zurückgegeben wird die ID mit dem Eintrag in der Liste. So hat die ImpulseInstanz immer Zugriff auf den ImpulseHandler.

/*
* @param :Object - scope. Ich kann dem Konstruktor den scope mit übergeben, 
* wo er denn callback ausführen soll. Dieser Parameter ist Optional.
* @param :Function - callback. Die Callback Funktion, die "onEnterFrame" 
* aufgerufen werden soll.Dieser Parameter ist Optional.
*/
function Impulse( scope:Object, callback:Function){
  _scope = scope;
  _callback = callback;
  _id = ImpulseHandler.connect( this );
}

// ImpulseHandler
function connect( ref:Impulse ):Number{
  _counter++
  _instancec[_counter] = ref;
  return _counter;
}

Die Function __loop__ im ImpulseHandler wird durch den "echten" onEnterFrame aufgerufen und führt die Funktion "execute" in allen "registrierten" ImpulseInstanzen aus.

// ImpulseHandler
function __loop__( Void ):Void{
  for( var i:String in _instances ){
   _instances[i].execute()
  }
}
// Impulse
function execute( Void ):Void{
  if( onEnterFrame != undefined )onEnterFrame();
  if( _scope != undefined )_callback.apply(_scope);
}

Benutzen kann ich den Impulse so:

// Ohne Callback
myImp = new Impulse();
// mit Callback
myImp2 = new Impulse( this, meineDerbeFunction );
// mit onEnterFrame
myImp3 = new Impulse();
myImp3.onEnterFrame = function(){
 trace( "hallo Flashforum" );
}

Jetzt habe ich absolute Kontrolle über meine "onEnterFrames". Mit den Methoden pause() und resume() kann ich den onEnterFrame für die Instanz genau steuern. dispose() dient als "quasi" Destruktor.

myImp = new Impulse()
myImp.pause();
myImp.resume();

Da ich ein Freund der 100 FramesPerSeconds bin, Ich stelle in der FLA immer 100 FPS ein, hatte ich eine weitere Idee. Mein AST (ActionScriptTween), das HauptProdukt meines Frameworks, ist ein Package zum Tweenen, Färben und transformieren jeglicher Elemente in einem FlashFilm. Da jeder Tween in meinem AST Zeitgesteuert ist und diese Berechnungen nun auch mit 100 FPS gemacht werden, der Mensch aber nur max 35 sieht, dachte ich es ist doch Sinnvoll, bestimmte "onEnterFrames" zu bremsen.

// Beispiel für AST
myTween = new AST( meinMC );
myTween.astR( 360, 3000, Bounce.easeOut );
// meinMc dreht sich in 3000 Millisekunden um 360 Grad.

Ich kann also auf meiner ImpulseInstanz per "setFrameRate" festlegen mit wieviel FPS die "execute" Methode auf der Instanz aufgerufen werden soll.

// Beispiel für AST
myImp = new Impulse();
myImp.setFrameRate( 100, 33 );
// Erster Parameter ist die eingestellte Framerate des FlashFilms, der zweite ist die gewünschte Framerate

Für meine AST's bedeutet das, das alle Berechnungen, die teilweise sehr Performance lastig sind, nur mit jedes 3.te mal gemacht werden. Die MovieClips, gleiten aber immer noch smoth daher. Dem Auge ist es egal, ob es nun 100 FPS oder 33 FPS sind.

Jetzt Fragen sich aber bestimmt alle, warum ich die FrameRate nicht einfach auf 33 FPS einstelle. Hehehe.. Ich gehe immer davon aus, wenn mein Film mit 100 FPS läuft, sind auch diverse Operationen einfach schneller, gerade Berechnungen die man auf einem onEnterFrame macht. So kann ich manche Berechnungen mit 100 FPS durchführen, und andere, gerade Display-ausgaben mit 33, oder noch weniger.

Da meine Framework noch in der Testphase ist, kann ich Euch den Code leider nicht bereitstellen. Ich denke Mitte Februar werde ich es releasen können.

Vielleicht ist das ia auch alles Quatsch was ich mir zusammen geschrieben und ausprogrammiert habe, aber erste Test lassen mich lächeln Mich würde aber interessieren ob Ihr so etwas auch habt, oder denkt "so'n Quatch"...

Sorry für den schlechten "Erklär-Bar-Stil", hab Schnupfen und bin Müde.

Gruß
Markus

ps: Ich habe noch für das bessere Gruppieren eine ImpulseGroup Klasse... hier kann ich einzelne ImpulseInstanzen zusammenführen, und über eine GroupInstanz nun die Methoden der einzelnen ImpulseInstanzen ausführen. Macht alles ein wenig übersichtlicher.

[Janoscharlipp]

Also das mit 100 Frames überzeugt mich nicht richtig.
Angenommen, ich habe eine Berechnung, die zwischen 10 ms und 40 ms dauert, dann würde dein onEnterFrame ins straucheln kommen, da dann nicht mehr die Regel jedes 3. Frame = 33 Fps zutrifft. Stellt man die Fps direkt auf 33 so ist die Framerate in dieser Hinsicht stabiler.
Alles grafische reicht schließlich 30 mal, warum also nicht 30 Fps einstellen?
Wenn du doch eine Berechnug öfters machen musst, kannst du ja setInterval nehmen.

[ms_hh]

Moin Janoscharlipp,

waum sollte ich denn so "wichtige" Berechnungen mit 33 FPS machen?. Ich habe ja die Möglichkeit einzelnen Instanzen unterschiedliche FPS zu "geben".

Ich glaube meine Ansicht über FramesPerSeconds kommt von Quake

Mit wieviel FPS arbeitest Du denn so?

Gruß
Markus

[Janoscharlipp]

Zitat von ms_hh

Ich glaube meine Ansicht über FramesPerSeconds kommt von Quake

Juchuhh!

Aber gerade bei Quake war es immer so, dass man besser 125 fps konstant hat, als dass sie zwischen 150 und 400 schwanken. (dafür auch com_maxfps).
Und das obwohl die Zeit in Quake eigentlich unabhängig von der Framerate ist, im gegensatz zu den meisten Flash-Filmen.

[ms_hh]

Hmmm wer sagt denn das meine FPS nicht konstant ist? Ist sie aber...

.ms