• Bitte schaltet eure Ad Blocker aus. SLinfo kann nur betrieben werden, wenn es durch Werbung Einnahmen erzielt. Vielen Dank!!
  • Wir freuen uns, wenn du dich in unserem Forum anmeldest. Bitte beachte, dass die Freigabe per Hand durchgeführt wird (Schutz vor Spammer). Damit kann die Freigabe bis zu 24 Stunden dauern.
  • Wir verwenden Cookies, um Inhalte und Anzeigen zu personalisieren, Funktionen für soziale Medien anbieten zu können und die Zugriffe auf unsere Website zu analysieren. Sie geben Einwilligung zu unseren Cookies, wenn Sie unsere Webseite weiterhin nutzen.

Prim mit 5 Seiten in einer Richtung?

E

Ezian Ecksol

Guest
Würde mir gerne mal das Objekt hier bauen:
http://wiki.secondlife.com/wiki/Mandelbrot_Explorer

In der Einleitung ist als Vorraussetzung erwähnt, dass man ein Prim braucht, welches Faces nach vorne zeigt:
// Add this script to a screen made from 245 linked prisms each manipulated to show 5 faces in one direction

Bin nicht so der Prim-Folterer. Mir fällt dazu nur ein, eine normale Box zu nehmen, Taper x und y je auf .55 und die Höhe des Prims auf den Mindestwert. Dann bekomme ich aber ein Prim, bei dem die Mitte viereckig ist, die anderen Seiten aber so blöde Trapezförmig.

Außerdem habe ich dann auch nicht die im Script erwähnten Faces:
list faces = [3,7,4,6,1];

Das ganze soll ja einen Screen ergeben und deshalb nehme ich an, sollen alle Faces möglichst quadratisch sein.

Wie mache ich so ein Prim?
 
Ja es funktioniert! Sieht aber recht bescheiden aus... oder ich hab da was falsch gemacht, keine ahnung:



sorry für die übergrösse, aber noch kleiner, und man hätte von dem "Mandelbrot" nix mehr mitbekommen
 
ähm.....ich habe das jetzt zwar gelesen, aber überhaupt nicht verstanden.

Na gut, man kann eben nicht verstehen :?
 
Kila Shan schrieb:
ähm.....ich habe das jetzt zwar gelesen, aber überhaupt nicht verstanden.

Na gut, man kann eben nicht verstehen :?

naja, das sieht nur ziemlich kompliziert aus, ist es aber eigentlich nicht.Muss man nur Schritt für Schritt anschauen.

Im Wesentlichen ist dieses Dings die Darstellung einer Folge von Zahlen.
Dabei ist die Regel für die nächste Zahl:

Zn+1 = (Zn)^2 + c

und Z0 = 0 (das ist die erste Zahl)

d.h. man kriegt die nächste Zahl indem man die Zahl quadriert und dann c addiert.

Z.B. kann so eine Folge von Zahlen sein:

(c=1)
0,1,2,5,26,677,458328,...

Nun kann man jede reelle Zahl (das sind die, die man in der Schule normalerweise kennt, also auch sowas wie Pi oder 2/3) auch als komplexe Zahl schreiben, in der Form a + b*i, d.h. die haben neben dem a (das entspricht der reellen Zahl) noch eine imaginäre Komponente b*i, wobei i die Eigenschaft hat: i * i = -1.
Bei den "normalen" reellen Zahlen ist eben b = 0.
Aber zu jeder "normalen" Zahl gibts so noch unendlich viele komplexe zahlen. Z.B. gibts zu der 1 noch 1+356i oder 1-676i oder 1+0,35i usw.

Sieht natürlich jetzt erst mal ziemlich verwirrend aus und macht auf den ersten Blick nicht so viel Sinn, aber wenn man genau hinschaut kann man damit dann jede algebraische Gleichung lösen und z.B. in der Physik damit eben komplizierte Differentialgleichungen und somit z.B. bestimmte Schwingungen recht einfach berechnen.

Wenn man Zahlen darstellen möchte benutzt man die Zahlengerade, da hat jede Zahl ihren Platz irgendwo, selbst eine Zahl, die man nicht wirklich bestimmen kann. Pi liegt z.B. irgendwo zwischen 3,1 und 3,2.
Für die Komplexen Zahlen gibt es zu jedem Punkt der Zahlengerade eben noch eine senkrechte Komponente b*i, d.h. man bekommt einfach eine Zahlenebene, auf der alle Komplexen Zahlen liegen.
Die x-Werte sind dann die reellen Zahlen, und auf der y-Achse liegen die imaginären Anteile.

Wenn man nun in die Folge von oben (Zn+1 = (Zn)^2 + c ) nicht mehr reelle, sondern komplexe Zahlen einsetzt, dann bekommt man nicht mehr nur nächste Zahlen, die auf einer geraden sind, man bekommt Zahlen, die irgendwo auf der Ebene liegen können, denn zwei komplexe Zahlen werden nicht nur a*a quadriert, da gilt dann: (a*a - b*b) + (a*a +b*b)*i.
D.h. die Verteilung der Zahlen auf der Ebene kann je nach c ziemlich chaotisch werden oder auch mal zwischen bestimmten Bereichen hin und her springen.

Mit c = 1+i ergibt sich so z.B:
0,1+i,1+3i,-7+7i,1-97i,...

Und nun gibt es eben auch Werte für c, für die sich diese Folge einem bestimmten Grenzwert nähert.

Man kann nun für verschiedene c ausrechnen, wie schnell (und ob überhaupt) sich die Folge für dieses c einem Grenzwert nähert bzw. ins Unendliche abdriftet.
Und dies kann man eben grafisch Umsetzen in der Ebene der komplexen Zahlen, d.h. jeder Pixel auf dem Bild entspricht einem Wert c in der Zahlenebene, und die Farbe des Pixels gibt dann an wieviele Schritte in der Folge möglich sind, bevor der Betrag der komplexen Zahl Zn einen bestimmten Wert überschreitet, wenn kein Grenzwert erreicht wird. Hat die Folge für c einen Grenzwert, dann ist das Pixel schwarz. (Und c ist dann in der Mandelbrotmenge).
 
Monalisa Robbiani schrieb:
http://johannahyacinth.blogspot.com/2007/04/better-mousetrap.html

Hey genial, darauf wäre ich nie gekommen. Thx :)

@ Carola Conover, schätze mal, du hast die Prims falsch verlinkt. Hier im Screenshot siehst du, wie es verlinkt werden muss. Die Prims liegen waagerecht, 7 nebeneinander pro Zeile. Dann 35 Zeilen vertikal übereinander. Link es zeilenweise, so dass oben rechts das letzte Prim ist und unten links das Rootprim.

Wer sich die Mühe ersparen will, kann den Screen inworld von mir gern bekommen. Ist in Mono echt rasendschnell, wenn man es mal mit dem alten LSL2 vergleicht. Wenn man drauf klickt, zoomt das Apfelmännchen rein.

unbenannt2kopielv7.jpg


PS: Damit die einzelnen "Pixel" quadratisch sind, habe ich x=0.010, y=0.500, z=0.087 genommen.
 
Ja, was ich vor allem nett finde, ist der Screen. Hab mir für ähnliche Spielchen mal einen Screen gebaut mit 13x13 Pixeln = 169 Prims. Wie naiv! :lol: Der hier hat 35x35 mit nur 245 Prims.
 
Noctua Janus schrieb:
Das Verfahren ein Prim mit 5 zum Benutzer zeigenden Oberflächen zu nutzen ist nicht neu, die Technik wurde soweit mir bekannt ist es erstmals von XYZZY Text eingesetzt um 10 Buchstaben auf nur einem Prim anzuzeigen.

Ob das Verfahren neu oder uralt ist, ist doch völlig wurscht. Ich kannte es jedenfalls nicht. Hätte ich es gekannt, hätte ich wohl kaum den Thread gemacht, um danach zu fragen.

Nun würde mich aber doch nochmal interessieren, wie man auf 5 Faces 10 Buchstaben kriegt (will mir das xyzzy-Script jetzt nicht antun). Die werden ja wohl keine Texturen mit Buchstabenpaaren benutzen.
 
So war das auch nicht gemeint, ich bezog mich mehr auf den Blogeintrag der ein wenig den Eindruck erweckt sie hätte die Sache erfunden. Ich kenne auch genug Techniken nicht die es schon länger gibt, dafür gibts ja hier den Platz zum Fragen ;)

Und doch, es sind jeweils zwei Buchstaben die zusammengefaßt sind. War glaube ich bei den Vorgängern auch schon der Fall, nur arbeiteten die mit 3 Flächen je Prim und hatten damit eben maximal sechs Buchstaben.
Jemand der mathematisch bewanderter ist als ich kann sicher erklären wieviele Kombinationen sich dabei ergeben, soweit ich weiß waren drei Buchstaben nie möglich weil die Kombinationsmöglichkeiten zuviele Texturen nötig gemacht hätten.

Das Script ist nebenbei echt super, kann ich für Anzeigetafeln nur empfehlen, es zerlegt sogar selbstständig längere Texte und verteilt sie auf die Tafeln. Diese muß man nur entsprechend benennen -> Wiki.
 
Noctua Janus schrieb:
wieviele Kombinationen sich dabei ergeben

26 Buchstaben (ohne Umlaute) ^ 2 = 676 Kombinationen.

Das ist das einzige in der Kombinatorik, was man sich gut merken kann.

Stell dir vor, du hast 10 Zahlen (0-9). Dann kann man mit den 2 Zahlen (00-99) 100 verschiedene Zahlenkombinationen herstellen, also 10 ^ 2 = 100.

Bei 3 Buchstaben wären es 26 ^ 3 = 17576 mögliche.

676 Texturen sind eine ganze Menge, vielleicht braucht man nicht alle davon, weil in der Sprache bestimmte Kombinationen, vielleicht sogar viele davon, gar nicht vorkommen.
 
*lach* Stimmt ist gar nicht so aufwendig zu berechnen. Wobei etwas mehr sind es schon, da noch Satzzeichen und Zahlen inklusive sind.

Es sind allerdings nicht 676 Texturen nötig sondern nur 66 (wenn ich mich nicht verzählt habe), denn es handelt sich nicht um eine Kombination je Textur, sondern eine größere Textur mit vielen Buchstaben aus denen dann über eine Offsetberechnung das jeweilige Paar ausgewählt wird. Eine anderer Berechnung ermittelt zuvor welche Textur genutzt werden muß.

Auf der Wikiseite ist sogar ein Script und eine Erläuterung wie man diese Texturen auch für andere Sprachen (also z.B. mit Umlauten) produziert.
 
Aber zurück zum 5-Faces-Prim. Schon witzig. Schmeißt mal dieses Script in ein Prim. Mit einem Prim kann man so 15 monochrome Pixel darstellen. Das Script zeigt 15-Bit-Zufallszahlen.

*Grübel* Aus 4 Prims pro Zeile und 60 Zeilen könnte man ein monochromes Display mit 60x60 Pixel bauen, was nur 240 Prims braucht ...

Code:
integer tx_pics = 8;
float tx_step;
float tx_base;

integer num;
key tx = "494baccc-1686-429a-b68f-0d7cd7624bee";

list getlist(integer data) {
    
    integer f1 = (data >> 12) & 7;
    integer f2 = (data >> 9) & 7;
    integer f3 = (data >> 6) & 7;
    integer f4 = (data >> 3) & 7;
    integer f5 = data & 7;
    
    return [    PRIM_TEXTURE, 1, tx, <2.48, tx_step, 0.0>, <-0.74, tx_base-(float)f5*tx_step, 0.0>, 0.0, 
                PRIM_TEXTURE, 6, tx, <1.0, tx_step, 0.0>, <0.0, tx_base-(float)f4*tx_step, 0.0>, 0.0, 
                PRIM_TEXTURE, 4, tx, <-14.75, tx_step, 0.0>, <-0.27, tx_base-(float)f3*tx_step, 0.0>, 0.0, 
                PRIM_TEXTURE, 7, tx, <1.0, tx_step, 0.0>, <0.0, tx_base-(float)f2*tx_step, 0.0>, 0.0, 
                PRIM_TEXTURE, 3, tx, <2.48, tx_step, 0.0>, <-0.25, tx_base-(float)f1*tx_step, 0.0>, 0.0];
}

default
{
    state_entry()
    {
        tx_step = 1. / (float)tx_pics;
        tx_base = 0.5 - tx_step / 2.;
        llSetPrimitiveParams([
                    PRIM_TYPE, PRIM_TYPE_PRISM, 32, <0.199, 0.8, 0.0>, 0.30, <0.0, 0.0, 0.0>, <1.0, 1.0, 0.0>, <0.0, 0.0, 0.0>,
                    PRIM_SIZE, <0.03, 2.89, 0.15>, PRIM_FULLBRIGHT, ALL_SIDES, TRUE, PRIM_COLOR, ALL_SIDES, <0., 1., 0.>, 1.,
                    PRIM_TEXTURE, 1, tx, <2.48, tx_step, 0.0>, <-0.74, tx_base, 0.0>, 0.0] +  
                    getlist(0));
                    
        integer i;
        while (TRUE) {
            i = (integer)llFrand(33554432.);
            llSetText((string)i,<1.,1.,1.>,1.);
            llSetPrimitiveParams(getlist(i));
        }

    } 
    

}
 
Frage: Kennt jemand ne Methode, aus einem Prim nur 4 quadratische, nach vorn zeigende Faces zu bauen? Für größere Displays wären die Berechnungen deutlich schneller, das wäre mir ein paar Prims wert ...
 
Hallo Ezian

Wenn du bei dem Prim mit 5 Seiten nach vorne das "hollow" weglässt und ein wenig den "path cut" anpasst, erhälst du ein Prim mit vier Seiten nach vorne.
Meinst du das so oder habe ich dich falsch verstanden?

Ich habe den Mandelbrot Explorer heute Abend auch gebaut, und nach anfänglichen Problemen mit der Linkreihenfolge funktioniert er jetzt, aber leider unheimlich langsam.

Du hast geschrieben mit Mono läuft er recht schnell, was muss man dafür machen? Muss das Script umgeschrieben werden? Oder funktioniert Mono erst mit dem neuen RC Viewer?
Sorry für die vielleicht dummen Fragen, aber ich kenne mich mit Scripten absolut nicht aus.
 
Seraina Benelli schrieb:
Du hast geschrieben mit Mono läuft er recht schnell, was muss man dafür machen? Muss das Script umgeschrieben werden? Oder funktioniert Mono erst mit dem neuen RC Viewer?

Ja, Mono kann man bisher nur mit dem aktuellen RC kompilieren. Mit dem normalen LSL kompiliert ist es saulangsam, quasi unbenutzbar.

Ich schieb dir das Mono-Teil mal rüber, dann brauchst du dir dafür nicht extra den RC zu installieren.

Seraina Benelli schrieb:
Wenn du bei dem Prim mit 5 Seiten nach vorne das "hollow" weglässt und ein wenig den "path cut" anpasst, erhälst du ein Prim mit vier Seiten nach vorne.

Mal probieren
 

Users who are viewing this thread

Zurück
Oben Unten