Loony Letters – Erste Eindrücke

Seit vier Tagen ist L.L. hochgeladen und die ersten Erkenntnisse sind ernüchternd: Massenhaft Abstürze, läuft nicht unterhalb Version 9.5., mehrere Tags funktionieren auch nicht.
Im plugincafe Forum kam auch noch der Hinweis, dass ein non-modal Dialog dafür wesentlich besser geeignet wäre – D.h. während der Eingabe läuft C4D weiter, man kann die neuen Werte sofort überprüfen, der Workflow wird dadurch natürlich erheblich gesteigert.
Leider ist ein non-modal Dialog wesentlich schwieriger umzusetzen, als ein modal Dialog, bei dem während der Eingabe alles gestoppt wird.
Außerdem muss getestet werden, welches Objekt aktiv ist, da nur dann die Parameter angezeigt werden sollen, wenn ein Loony Letter Text angewählt ist.
Der Denkansatz ist: Es werden 2 Plugins verwendet. Eins ist das eigentlich expressionplugintag, welches die Buchstabenpositionen, rotation, Skalierung etc berechnet. Da non-modal Dialoge nur bei Menu Plugins funktionieren, kommt eben noch ein solches zum Einsatz: der Loony Letters Editor. Der übergibt die Werte an das Tag… und zwar per basecontainer. Der Editor holt sich die Werte aus dem Tag, wenn er keine findet, verwendet er Standardwerte. Bei jeder Änderung der Parameter wird der gesamte Basecontainer wieder an das Tag übergeben.
Soweit die Theorie, bisher scheint das ganz gut zu laufen und auch die Abstürze haben sich auf ein erträgliches Minimum reduziert.
Die Abwärtskompatibilität werde und kann ich nicht herstellen, erstaunlicherweise läuft Loony Letters wohl auch unter R10.

Mehr zu Loony Letters in den folgenden Tagem.

4 Responses to “Loony Letters – Erste Eindrücke”

  1. eightyf sagt:

    Es klappt tatsächlich so, wie ich mir das gedacht hatte, also mit den oben erwähnten ZWEI plugins, die sich gegenseitig Daten zuschanzen.
    Inzwischen hat sich einiges getan, so ist es nun auch möglich, Presets zu speichern / laden. Außerdem hat das Eingabefenster auch noch vier sogennante Quickloads verpasst bekommen. Bei diesen handelt es sich eigentlich nur um Textfelder mit jeweils einem USE Button davor und einem SET Button dahinter. Wenn man nun eine Einstellung gefunden hat, die einem eigentlich gefällt, man aber noch nicht ganz sicher ist, ob das wirklich das Endergebnis ist, dann kann man sie einfach per SET auf eine der Quickloads legen und bei Bedarf mit USE wieder abrufen. Natürlich kann man auch eine kurze Beschreibung eingeben. Wenn einem dann alles gefällt, speichert man die Settings einfach als Preset ab.
    Bisher scheint mir das vom Workflow relativ gut zu funktionieren, da man nicht immer wieder den „Öffnen“ Dialog zu bemühen braucht, sondern einfach kurz auf Use klickt und die abgespeicherten Einstellung sofort wieder zur Hand hat.

  2. eightyf sagt:

    Eigentlich wäre jetzt alles für einen Relaunch bereit, aber nun hat mich wohl der Größenwahn gepackt… Ich will unbedingt die schicken Spline Interpolations Graphen haben, mit denen man die Keyframe Pfade definieren kann. Das geht mit Coffee nicht – heißt es. Seit vier Tagen wühle ich mich jetzt schon durchs Netz und lande meist auf Seiten mir der Endung .edu oder so. Das Schlüsselwort heißt kubische Spline Interpolation und beinhaltet Dinge, die mich schon vor 25 Jahren zur Verzweiflung getrieben haben. Infinetisimal- und Differntialrechnung sowie 1., 2. und 3. Ableitung – Juhuuuuu!!! Ich versteh‘ gar nichts, bin allerdings relativ optimistisch, dass ich das Ganze irgendwie implementiert bekomme.
    Sprich eine User Area, in der der Spline Graph gezeichnet wird. Der Anwender kannn maximal drei weitere Knotenpunkte einfügen, um einen weichen Kurvenverlauf zu generieren. D.h. dass auch an dieser Stelle bereits die Splineinterpolation zum Einsatz kommen muss – wenn auch in wesentlich kleineren Umfang, da die gesamte Userarea nur 200×50 Pixel groß ist. Allerdings muss auch der gesamte Graph berechnet werden. Bei einer Strichlänge von 5pixeln bedeutet das 40 Integralrechnungen und 3 Ableitungen… ob da noch flüssiges Arbeiten (im Dialogfenster) möglich ist, bleibt zumindest fraglich.
    An das Expressionplugintag werden dann nur die vier Knotenpunkte übergeben und dort wird der Faktor berechnet, mit dem der Animationsparameter (z.B. X-Position=500) multipliziert wird. Auch hier ist fraglich, ob das ganze noch in Echtzeit ablaufen kann. Eine Idee wäre, dass man die Multiplikatoren „backt“ und in ein Array in der Größe der Animations-Dauer schmeißt. Bei der Wiedergabe wird dann einfach der passende Wert für das aktuelle Keyframe ausgelesen und mit dem Animationsparameter multipliziert.
    Da kommt dann allerdings ein ganz schöner Batzen an Daten zusammen.
    Ein Beispiel:
    Bei einer Dauer von 50 Frames, benötigt man alleine NEUN Arrays mit jeweils 50 Elementen! Neun? Weil – konsequenterweise – alle X,Y,Z Parameter der Position, Rotation und Skalierung mit einer Splinesteuerung versehen werden müssen – und eigentlich auch die Fade-Werte (welches dann ein Flackern möglich machen würde). Und im Moment reden wir nur über die Animation Rein – Sprich, 18 Arrays mit jeweils 50 Elementen die einzeln im Basecontainer der Tags abgespeichert werden sollen. Leider, da es nicht möglich ist, ein Array im Container direkt zu speichern.
    Wenn das nicht funktioniert bin ich ziemlich gefrustet, aber irgendwie klappt das schon…
    André

  3. eightyf sagt:

    Yehaaawww!!!! Loony Letters gibt’s jetzt auch mit Spline-Graphen!!!
    OK, eins vorweg: Ich habe das mit der nten Ableitung des xten Polinoms immer noch nicht kapiert. Die Versuche, im Netz gefundene Source Codes aus anderen Programmiersprachen in C.O.F.F.E.E. zu übertragen, waren – höflich formuliert – kläglich. Als ich zum hunderttausendsten Mal das SDK durchforstete, kam mir eine Idee – und sie funktioniert!
    Der Trick ist, ein Spline-Object zu erstellen. Hierfür habe ich eine Funktion geschrieben, die als Eingabe-Parameter ein Array bekommt (in dem die Stützknoten gespeichert sind), die aktuelle Knotenzahl (max 5) und die „Position im Spline“, also wo auf dem Spline wir uns gerade befinden, sprich Werte zwischen 0.0 (am Anfang) und 1.0 (am Ende).
    Die Stützknoten werden im Dialog (in der UserArea) durch den Anwender bestimmt, also eingefügt, gelöscht, verschoben etc. Die eigentliche Schwierigkeit war es, diese Knoten durch eine glatte Kurve zu verbinden. Wie gesagt, die Stützknoten wurden ja bereits definiert, und in einem Array als Vektoren gespeichert. Dieses Array wird an die oben erwähnte Funktion übergeben.
    Mit
    cspline=new(SplineObject);
    wird ein neues, leeres SplineObject erstellt.
    nachdem man Coffee mitgeteilt hat, wieviele Punkte das Spline haben soll –
    vc=new(VariableChanged);
    vc->Init(0,knotenanzahl);
    cspline->Message(MSG_POINTS_CHANGED,vc);
    – kann man die Punkte setzen:
    cspline->SetPoints(Knotenarray);
    Da sich die Anzahl der Knoten immer ändert, das Array im Dialog aber immer 5 Elemente beinhaltet, habe ich in der Funktion ein neues Array erstellt, dass nur die wirklich verwendeten Knotenpunkte enthält.
    Die Funktion gibt o.g. Punkt auf dem Spline zur Zeit x als Vektor aus.
    Im Dialog-Scripting kann dieser Vektor durch den Aufruf der neuen Funktion nun ermittelt und mit einer For-Schleife zum Zeichnen verwendet werden:
    XX=knots[0].x; //X-Wert des ersten Knotens
    YY=knots[0].y; //Y-Wert des ersten Knotens
    for (t=0.0;t<1.05;t+=0.05) //Die Schleife wird 20 Mal durchlaufen
    {
    spline_vec=f_cubic_spline(knots,knotcnt,t); //liefert den Positionsvector
    X=spline_vec.x; //extrahiere X Wert aus dem Vector
    Y=spline_vec.y; //extrahiere Y Wert aus dem Vector
    bmp->DrawLine(XX,YY,X,Y); //Zeichne Teilstück
    XX=X; // Definiere aktuellen Wert als neuen Ausgangswert
    YY=Y; // des nächsten Teilstückes.
    } //Schleifenende
    Ich bin total happy – jetzt muss ich es nur noch schaffen, das Knotenarray irgendwo zwischenzuspeichern und dann an den basecontainer des expressionplugintags zu übergeben.
    Dort wird dann ebenfalls die Funktion f_cubic_spline(knots,knotcnt,t) aufgerufen, um den Multiplikator für das aktuelle Frame zu berechnen.
    Dieser Wert wird dann mit dem Animationswert von z.B. der X-Position multipliziert und sollte somit eine Bewegung entsprechend des Spline-Graphen erhalten.
    Dumdidummdidumm.
    So, weiter geht’s, mein Größenwahn kennt keine Grenzen!
    André
    Mit dem Befehl GetSplinePoint(x) erhält man den Punkt auf dem Spline zur Zeit x.

  4. eightyf sagt:

    Wunderbar, Loony Letters 1.1 steht zum download auf http://www.c4d-goodies.de bereit.
    Noch ein paar Bugs, die es zu bereinigen gilt, aber wenn man diese kennt, dann kann man mit dem Plugin relativ vernünftig arbeiten.
    Im Moment liegt die Arbeit an Loony Letters etwas brach, da arbeitsmäßig einiges an Zeit draufgeht – und auch die Familie will mal wieder was von mir haben 😉
    Allerdings gibt es ein paar nette Ideen für neue features, so z.B. das mit dem Referenzobjekt.
    Auch sollte es eigentlich nicht zu schwer sein, anstatt eines Textobjektes, eine Gruppe von Objekten zu animieren.
    Was allerdings schon schwieriger ist, ist ein Loony Shader, der Objekte anhand ihrer Geschwindigkeit (Größe, Position, Rotation???) beeinflusst.
    Keinen Ahnung, wie ich das umsetzen soll – die Shaderbeispiele aus dem SDK und dem Netz kapiere ich nicht so wirklich.
    Chic wäre auch ein Gradient, der steuert wieviel von dem Ausgangsobjekt überhaupt beeinflusst wird. Allerdings fehlt mir auch hierfür der Ansatz 🙁
    Aber das klappt schon irgendwie!!
    Grüße
    André

Leave a Reply

You must be logged in to post a comment.