Zitat:

---

Original von MaikG:
>Mir leider nicht, hab da zumindest mit den Stichworten AOS4 NAPALM
>nix finden können (und ich kann kein Polnisch etc.).
Da gibts Buttons "Seiten auf Deutsch" oder "Seiten aus Deutschland".

Stimmt aber, es ist schwer die richtigen begriffe einzugeben.

Amiga OS4 Napalm - würde ich probieren.

---

Zitat:

---

Original von Andreas_Wolf:
Da nützt dir aber die Erkenntnis, dass es auf einem Classic-Amiga unter OS4 läuft, rein gar nichts.

---

Zitat:

---

Original von Bluebird:
@Reth: naja du sprachst ja vom klassik wieso sollte man das auf aos4 zum laufen bringen wenn man ne echte 60er hat ?

---

Zitat:

---

gut wenn man zufaul zum neuboot ist ...

---

Zitat:

---

aber wie gesagt am nextgen os4 rechner koennte es dann probleme geben da man eben die paula nicht mehr hat oder gibts da ne alternative (hack)

---

Zitat:

---

Original von Der_Wanderer:
Durch ein geeignetes mapping von den Zufallswerten auf Farben.
Und auf jeden Fall mehrere Layers benutzen, die jeweils aus einem Perlin Muster bestehen.

Das hier sind Muster, die direkt aus Perlin Noise entstanden sind, ohne Nachbearbeitung, nur durch interpolieren der Zufallszahlen auf zwischen zwei RGB Farben:

Bild: http://www.hd-rec.de/pics/perlin.jpg

---

Zitat:

---

Zitat:

---

Wird auf der Freespace-Seite durch das Aufrufen aller PN-Funktionen pro Pixel schon das Endergebnis erreicht (also das übereinandergelegte Bild)?

---

Ja.

---

Zitat:

---

Lass die Glättung erstmal sein und versuche so ein Muster zu erzeugen.
Dann hast du schonmal den Perlin Noise Algo richtig gemacht. Alles andere ist Nachbearbeitung.

---

Zitat:

---

Original von MaikG:
>Das höre ich heut zum ersten Mal!

Google hilft :-)

---

Zitat:

---

Original von MaikG:
Ohne JIT gehts immerhin ruckelig.

Den OS4 RTG Patch musst du installieren.

---

Zitat:

---

Original von Der_Wanderer:
Ich meinte Algo (Algorithmus). hab das Posting korrigiert.

---

Zitat:

---

Kurze Grashalme sind dunkel, weil sie im Schatten sind, und lange sind hell, weil sie in die Sonne ragen. Dazu noch ein wenig Zufall und du hast es.

---

Zitat:

---

Original von Der_Wanderer:
Alles, was flach auf dem Boden liegt, kann man gut mit PerlinFX machen. Grässer auch, indem man einfach einen alog macht, der einen Grashalm zeichnet, und man nimmt ein Perlin Noise Muster als Grundlage wie lang er wird. So ist das Grass auf den Bilder oben gemacht. Ähnliches geht auch mit Geröll, wenn man das Perlin Noise als Bumpmap oder Displacement map nimmt.

---

Zitat:

---

Original von julius:
@Reth:
96MB Hauptspeicher.
julius

---

Zitat:

---

Original von Der_Wanderer:
Ich kann dir aber verraten, wie die meisten Tree-Gens funktionieren, und zwar mit einer (i.A. contextfreien) Grammatik.
Das thema hatten wir hier in einem Thread schonmal besprochen.

http://www.amiga-news.de/forum/thread.php?id=27069&BoardID=7

---

Zitat:

---

Ansonsten kannst du dir den "TreeGen" angucken im Amiblitz3 Archive, allerdings ist das sehr (sehr!) Alpha und der Sourcecode nicht sehr aufgeräumt. Aber ich werde das ausbauen und mit einer hübschen GUI versehen.

Allerdings solltest du dich vorher mehr in Mathe und 3D Sachen fitter machen. Das ist schon anspruchsvoller als Perlin Noise.

---

Zitat:

---

Original von Der_Wanderer:
Also die Formel ist hier, nur in mehreren Schritten:

code:

---

source_intx = Floor(source_x)       // ganzzahlige coos ermitteln
source_inty = Floor(source_y)
x_frac = source_x - source_intx  // überschüssige bruchteile ermitteln
y_frac = source_y - source_inty

---

Hier wird der Bruchteil ermittelt, der zum rechten/oberen Pixel fehlt

---

Hm? Zum linken/oberen Pixel, oder versteh ich das falsch (will nicht pedantisch sein, aber kann ja sein, dass jmd. das Ganze später auch mal zu Rate zieht, wird glaub ich gerade ein tolles Tutorial !)?

Zitat:

---

Man könnte es auch splitten und folgendes machen:

code:

---

obere_reihe  = source_pixel(source_intx   ,source_inty) * (1-x_frac) 
             + source_pixel(source_intx+1 ,source_inty) * (x_frac)
untere_reihe = source_pixel(source_intx   ,source_inty+1) * (1-x_frac) 
             + source_pixel(source_intx+1 ,source_inty+1) * (x_frac)

// ... und jetzt die beiden Reihen y interpolieren:

dest_pixel(dest_x,dest_y) = obere_reihe * (1-y_frac) + unter_reihe * y_frac

---

---

Zitat:

---

Original von Der_Wanderer:
> Gibt es einen Grund, warum nur die darunter und rechts daneben liegenden Pixel betrachtet werden und nicht alle umliegenden?
Ja. Es gibt nur 4 umgebende Pixel.
Beispiel:
Nimm einen Bleistif und mache zufällig einen Punkt auf karriertes
Papier. Jetzt gibt es genau 4 Ecken (=Pixel), die diesen Punkt einschliessen.

---

Zitat:

---

Original von Der_Wanderer:
Zur berechnung brauchen wir nun alle umliegenden Pixel von
(1.25,0), was i.A. 4 Stück sind: (1,0); (2,0); (1,1); (2,1)

---

Zitat:

---

Da es (2,0) auf der 2x2 nicht gibt, müssen wir wrappen und landen wieder auf 0, ist also ein spezialfall weil es am rand liegt.

---

Zitat:

---

Original von Der_Wanderer:
@Reth:
Ich weiss nicht was du hast. Auf der freespace seite wird das alles ausführlich erklärt. Dort wird die lineare und cosinus interpolation mit zwei Punkten und die cubische mit mehr punkten erklärt. (1 Dimensional)

---

Zitat:

---

In dem Sourcecode von meinem letzen Posting siehst du genau wie es geht.

Lineare Interpolation:
Sagen wir du hast an der stelle 5 der Wert 100 und an der stelle 6 den Wert 200.

Dann hast du an der stelle 5.2 den Wert

frac = 5.2 - Floor(5.2) = 5.2 - 5.0 = 0.2
y = (1-frac) * 100 + frac * 200
= 0.8 * 100 + 0.2 * 200 = 80 + 40 = 120

Wenn es zweidimensional ist, dann kommen eben noch unten zwei pixel dazu, und es gibt einen frac_x und frac_y.

---

Zitat:

---

Original von Der_Wanderer:
Bei linearer Interpolation betrachtet man immer vier Pixel, um einen zu berechnen, und zwar einen 2x2 block. Man berechnet den Wert dann in Abhängigkeit von der Nähe, linear interpoliert.

---

Zitat:

---

"Löcher" gibt es dadruch, dass man die werte einfach ab einem bestimmen schwellwert abclippt, z.B. unter 50 setzt man gar keinen Pixel.

---

Zitat:

---

Original von Der_Wanderer:
Och Reth, ein bisschen anstengen solltest du dich schon. Und schreibe am besten alles von Grund auf selbst, dann verstehst du es am besten.

---

Danke für Deine Erklärung!

Aber genau das versuche ich ja! Ich dachte, dass kommt aus meinen Posts deutlich raus? Darum ja die grundsätzlichen Verständnisfragen und mein bisheriger Code. Ich sagte doch, dass ich die Funktionen nicht einfach nur abtippen, sondern verstehen will!

Was glaubst Du, was ich die letzten Tage stundenlang versucht habe (und davon einige Stunde mit dem Versuch verbracht habe, die mathematischen Grundlagen aufzufrischen/zu verstehen, v.a. für Interpolation - allerdings haben die gefundenen Artikel im Wiki und sonstwo eher zur Verzögerung beigetragen; so eine anschauliche Beschreibung, wie Du sie ablieferst wirkt da schon deutlich schneller!)!

Wie soll ich denn was von Grund auf selbst schreiben, von dem ich nicht weiß wie es geht? Da muss ich mich ja erst einlesen, und dabei tauchten dann genau die Fragen auf!

Zitat:

---

Ein 24 bit RGB Wert besteht aus Rot, Grün und Blau Werten jeweils zwischen 0-255 (8-Bit). Was wir machen werden ist, einen (Pseudo-)Zufallswert X ermitteln und den dann sichtbar machen, indem wir ihn in einen RGB Wert verwandeln.
Es gibt viele Möglichkeiten das zu tun, die einfachste ist, X sofort zwischen 0..255 zu berechnen und dann R=X, G=X, B=X zu machen. Dadurch bekommen wir Grauwerte. Wenn du einen bestimmten Farbwert vorgeben willst, dann geht das so:

---

Zitat:

---

Sagen wir, wir wollen ein 8x8 Pixel grossen Muster berechnen.
Dann berchnen wir 64 solcher X Werte und plotten sie der Reihe nach in das 8x8 Quadrat.

Das ist bis jetzt noch kein Perlin Noise Muster, sondern nur "triviale" Noise.

---

Zitat:

---

Die Idee die Perlin hatte ist, dass man verschiedene Schichten von Rauschen übereinanderlegt

---

Zitat:

---

Eine Persistenz von 0.5 bedeutet, dass wir von einer Schicht zur nächsten die höhe der Erhebungen/Täler halbieren.
So eine Schicht nennt man auch "Oktave", weil bei Perlin Noise üblicherweise die nächste schicht immer doppelt so fein ist, wie die Frequenzen in der Musik
sich von einer Oktave zur nächsten verdoppeln.

---

Zitat:

---

Also schauen wir uns erstmal mal 4x4 an.
Da gehen wir so vor, dass wir wie die 8x8 Schicht das berechnen, nur eben 4x4 gross, also 16 Zufallswerte.
Wenn wir das jetzt mit 8x8 mischen wollen, müssen wie 4x4 auf 8x8 "zoomen".
Also zwischen den einzelnen Werten brauchen wir noch einen Zwischenwert, den wir durch Interpolation der
beiden drumherum leigenden bekommen, also irgendwie ein mittel finden.
Im einfachsten Fall ist das die lineare Interpolation, also setzen wir immer das mittel dazwischen.

---

Zitat:

---

Bei Verdopplung ist die lineare inerpolation gerade das arithmetische mittel zwischen den benachbarten Punken.

---

Zitat:

---

haben wir eine Persistenz von 0.5, dann
nehmen wir das 2x2 Array, addieren die Zahlen von 4x4 drauf mit 0.5 multipliziert und die von 8x8 mit 0.5*0.5 = 0.25 multipliziert.

Also

X = X_2 + X_4*0.5 + X_8*0.25

Da der Wertebereich von X jetzt von 0..255*(1+0.5+0.25) = 0..446.25 geht, scalieren wir X noch

X = X * 255 / 446.25

---

Zitat:

---

Das dient dann als Ausgangsmaterial für alle möglichen Spielereien.

Bild: http://www.hd-rec.de/pics/perlin1.jpg Bild: http://www.hd-rec.de/pics/perlin2.jpg Bild: http://www.hd-rec.de/pics/perlin3.jpg

Bild: http://www.hd-rec.de/pics/growgrass.png

Bild: http://www.hd-rec.de/pics/mountain_grass4.jpg

---

Zitat:

---

Original von whose:
@Reth:

Heißer Tip: Schau Dir mal die "optionalen" Sachen an und installier das Zeug (soweit möglich).

---

Zitat:

---

Arial (zu finden auf einem Windows-System Deines Vertrauens ) sollte schon helfen. Achte darauf, daß Du nur die Teile aus den "corefonts" nach FONTS: kopierst, für die Du die entsprechenden TTF-Fonts hast. Arial allein bringt schon eine Menge, damit waren die Alerts und DSIs bei mir schon erledigt. Ob das für alle Seiten gilt, weiß ich nicht, aber auf meinen Seiten tut OWB nun ohne weitere Alerts und DSIs.

---

Java code:

---

float p = 1f; // Persistenz, der Einfachheit halber 1

// der Einfachheit halber nur ein Durchgang (also nur eine Noise-Funktion)
for (int round=1; round<=1; round++)
{
    // Frequenz und Amplitude der Einfachheit halber 1
    int frequency = (int)Math.pow(2, round);
    float amplitude = (float)Math.pow(p, round);

    // Abstand zwischen den zu berechnenden Punkten, alle 
    // dazwischenliegenden werden interpoliert
    int offset = 1;

    // ein Bereich von 100x100 Pixeln in der Mitte eines schwarzen
    // Quadrates, Schrittweite = offset
    for (int x=20; x<=100; x+=offset)
    {
	for (int y=20; y<100; y+=offset)
	{
            // Noise-Wert des aktuellen Pixels berechnen
            float rand = getNoise(x*frequency, y*frequency) * amplitude;
	    
            // Farbe mit Hilfe des Noise-Wertes setzen und Pixel malen    
            g.setColor(new Color(Math.abs((int)(rand*125f)), Math.abs((int)(rand*125f)), Math.abs((int)(rand*255f))));
	    g.fillRect(x, y, 1, 1);

            // Wenn Schrittweite>1 => interpolieren aller Zwischenpixel
	    if ((offset > 1))
	    {
	        // Alle Zwischenpunkte interpolieren
		for (int j=1; j<offset; j++)
		{
		    // Y, aber nicht für ersten Durchlauf
		    if (y > 20)
		    {
                        // Noise-Wert des 2. Randpunktes bestimmen
			float randInt = getNoise(x*frequency, (y-offset)*frequency) * amplitude;
                        // interpolierte Noise-Wert, der 3. Parameter
                        // bestimmt sich aus 1/Schrittweit multipliziert
                        // mit dem aktuellen Durchlauf (also bei 
                        // Schrittweite 2 ergibt sich 0,5; bei 
                        // Schrittweite 3 ergeben sich 0,33 und 0,66 etc.)
			rand = interpolateCos(rand, randInt, j*(1f/(float)offset));
                        // Farbwert setzen und Pixel zeichnen
			g.setColor(new Color(Math.abs((int)(rand*125f)), Math.abs((int)(rand*125f)), Math.abs((int)(rand*255f))));
			g.fillRect(x, y-j, 1, 1);

                        // X, aber für alle y-offset
			if (x > 20)
			{
			    for (int k=1; k<offset; k++)
			    {
				randInt = getNoise((x-offset)*frequency, (y-k)*frequency) * amplitude;
				rand = interpolateCos(rand, randInt, (offset-j)*(1f/(float)offset));
				g.setColor(new Color(Math.abs((int)(rand*125f)), Math.abs((int)(rand*125f)), Math.abs((int)(rand*255f))));
				g.fillRect(x-j, y-k, 1, 1);
			    }
			}
		    }
		}
            }
	}
    }
}

---

Java code:

---

private float interpolateCos(float a, float b, float x)
{
    return (float)(((1+Math.cos(x*Math.PI))/2 ) * a + ( 1 - (1+Math.cos(x*Math.PI))/2 ) * b);
}

---

Java code:

---

private float getNoise(int x, int y) {
    int n = x + y * 57;
    n = (n << 13) ^ n;
    return 1.0f - ((float)( (n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff)) / (float)1073741824;
}

---