ENGLISH VERSION |
|
Links | | | Forum | | | Kommentare | | | News melden |
Chat | | | Umfragen | | | Newsticker | | | Archiv |
amiga-news.de Forum > Suche | [ - Suche - Neue Beiträge - Registrieren - Login - ] |
|
||||||
Reth
Nutzer
26.02.2008, 10:08 Uhr [ - Direktlink - ] |
Thema: NAPALM auf AOS4 - Schon was Neues?
Brett: Amiga, AmigaOS 4 Zitat: Wenn Du den Thread auf OS4Welt meinst, den finde ich nun nicht wirklich hilfreich, da ich keine Ahnung habe, was TetiSoft da mit dem Audio-Device meint (liest sich für mich, als ob er sich ne eigene Version programmiert hat). Der einzige Hinweis dort ist, es in die DOS-Blacklist einzutragen, muss ich noch versuchen. Allerdings brauch man es wohl laut diesem Thread nicht in die JIT-Blacklist aufnehmen! Schlussendlich kommt aus dem Thread nicht hervor, ob es läuft! Zitat: Das ist nicht gesagt, da es u.U. OS-bedingte Probleme geben kann, die von der unterliegenden HW unabhängig sind! |
|||||
Reth
Nutzer
25.02.2008, 22:53 Uhr [ - Direktlink - ] |
Thema: NAPALM auf AOS4 - Schon was Neues?
Brett: Amiga, AmigaOS 4 Zitat: Na dann schau Dir mal das Thema von dem Thread an! Dann, weisst Du warum ich nochmal auf AOS4 hingewiesen habe! Zudem gehe ich nicht davon aus, dass mein 4000er ewig hält (für AOS4 und native Anwendungen ist er auf Dauer eh zu schwachbrüstig). Zudem ist NAPALM eines meiner Lieblingsgames und ich würde es auf einem aktuelleren AOS4-Rechner auch gern wieder spielen (wenn es den jemals wieder geben wird)! Zitat: Wenn ich wegen jedes Spiels/jeder Anwendung immer erst ins andere OS booten muss - na dann gute Nacht! V.a. weil beide OS 2 Resets benötigen um durchzubooten. Sehe mich hier nicht als zu faul, sondern will gern unter einem OS bleiben und nach ner Spielrunde gleich was anderes machen! Dasselbe gilt für die ganzen alten Games, die unter OS3.9 z.T. mit WHDLoad laufen. Aber den EUAE unter AOS4 aufm A4000 brauch man wohl nicht erst anzuwerfen! Zitat: Der Hack nennt sich Nalle-Puh, hat aber bei mir auch noch nicht funktioniert! Ciao |
|||||
Reth
Nutzer
25.02.2008, 22:01 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung Zitat: Welche Werte muss ich denn da beeinflussen um auf so ein Wolkenbild zu kommen? Nur die Persistenz? Zitat:Zitat:Ja. Das funktioniert bei mir nicht! Wenn ich den Algo von der Freespace-Seite unverändert übernehme, dann komme ich nicht auf das Ergebnisbild der blauen Plasmawolke. Allerdings wird dort ja gesagt, dass man so viele unterschiedliche Nosie-Funktionen braucht, wie man Iterationen macht. Leider finde ich nirgends eine Primzahltabelle, in der so große Primzahlen drin sind (habe nur versch. Werte für die beiden kleineren Primzahlen gefunden, dort immer 10 benachbarte Primzahlen genommen)! Zitat: Wie gesagt bekomme ich nur das erste Muster hin, aber nicht das Endbild! Auf der Freespace-Seite ist auch nicht gesagt, wie oft die Schleife durchlaufen wird, die immer eine andere PN-Funktion ruft. Dazu kommt dann noch das Problem mit den großen Primzahlen! Ciao |
|||||
Reth
Nutzer
25.02.2008, 21:52 Uhr [ - Direktlink - ] |
Thema: NAPALM auf AOS4 - Schon was Neues?
Brett: Amiga, AmigaOS 4 Zitat: Mir leider nicht, hab da zumindest mit den Stichworten AOS4 NAPALM nix finden können (und ich kann kein Polnisch etc.). Hast Du vielleicht den direkten Ergebnislink aus Google? @tommysammy: @bluebird: Äh, ich sprach von AOS4! Unter AOS3.9 läufts auf meinem 060er auch flüssig genug! Ciao [ Dieser Beitrag wurde von Reth am 25.02.2008 um 22:26 Uhr geändert. ] |
|||||
Reth
Nutzer
25.02.2008, 16:10 Uhr [ - Direktlink - ] |
Thema: NAPALM auf AOS4 - Schon was Neues?
Brett: Amiga, AmigaOS 4 Zitat: Das höre ich heut zum ersten Mal! Wow! Läufts auf dem A1 oder Micro bei Dir oder aufm Classic? Welchen Patch meinst Du? Liegt der im OS4Depot oder ist der speziell für NAPALM? Ciao |
|||||
Reth
Nutzer
25.02.2008, 12:49 Uhr [ - Direktlink - ] |
Thema: NAPALM auf AOS4 - Schon was Neues?
Brett: Amiga, AmigaOS 4 Hallo zusammen, da nun AOS4 mittlerweile schon einige Zeit in den Händen (hoffentlich) vieler Classic-User ist, wollte ich fragen, ob schon jemand Erfolg damit hatte, NAPALM auf AOS4 zum Laufen zu bringen. Die Threads der Vergangenheit klangen z.T. ja schon recht vielversprechend! Ciao |
|||||
Reth
Nutzer
23.02.2008, 00:09 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung @Der_Wanderer: Also das mit dem Alpha-Blending leuchtet ein. Wenn ich allerdings daran denke, dass ich gern Landschaften und Türme rendern würde, sehe ich schwarz. Sprich, ich denke, dass ich dann durch mein wenig begabtes Pixeln immer noch schneller zu Ergebnissen komme. Aber ich werde den algorithmischen Teil auf alle Fälle weiter probieren. Überlege z.B. auch gerade, wie man das macht, wenn man eine Textur hat (Mauerwerk) und diese dann auf einen Zylinder blittet (Turm). Wenn man das nur so 1:1 macht, denke ich wird das nicht sehr plastisch aussehen, oder? Kannst Du noch ein paar Tips zu Perlin Noise geben, wie man z.B. so schöne Landschaften hinbekommt, wie bei Dir? Durch Übereinanderlegen verschiedener PN-Muster mit unterschiedlichen Farben und Schwellwerten? Und noch Verständnisfragen: Wird auf der Freespace-Seite durch das Aufrufen aller PN-Funktionen pro Pixel schon das Endergebnis erreicht (also das übereinandergelegte Bild)? Wie komm ich denn auf die Glättung, so wie auf der Freespace-Seite. Mir ist klar, dass der Pixel selbst den größten Anteil hat, die Pixel die direkt an seinen Seiten anliegen den zweitgrößten und die Pixel, die nur an die Ecken stoßen den geringsten und die Gesamtsumme der Gewichte 1 sein muss. Aber dass die 4 Eckpixel 1/4, die 4 Seitenpixel 1/2 und der Pixel selbst 1/4 an Gewicht ausmachen, wie komm ich da drauf? Eigenartig ist auch, dass ich, wenn ich den Algo von der Freespace-Seite ohne Glättung nehme auch auf das erste (rechte) Bild der ersten Noise-Funktion komme. Mit Glättung dagegen sieht das Ganze erheblich dunkler aus, hat viel mehr schwarz dazwischen. Das kann ich mir nun nicht erklären! Ciao [ Dieser Beitrag wurde von Reth am 23.02.2008 um 22:34 Uhr geändert. ] |
|||||
Reth
Nutzer
22.02.2008, 16:09 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung @Der_Wanderer: Und das Ganze Zeugs wie Alphablending etc. hast Du dafür selber implementiert? Nach dem Schatten frage ich lieber gar nicht erst! Etwa auch komplett selbst implementiert (also Lichtquelle mit Winkel, Helligkeit, Entfernung, Überdeckung von Objekten im Licht, ...)? Ciao |
|||||
Reth
Nutzer
22.02.2008, 15:59 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung @Der_Wanderer: Stimmt. Dachte, da gibts bestimmt auch wieder hochkomplizierte Renderalgos. Ich würde mal zufällig lange, krumme, breite Linien zeichnen, deren Ausgangspunkte dicht beieinander liegen. Allerdings müsste man das Ganze dann wieder irgendwie "nicht ganz" zufällig entstehen lassen, aber hier kommt ja Dein Perlin-Noise-Gedanke mit der Höhe ins Spiel. Warum der aber funktioniert, weiß ich auch nicht, muss ja dann ein Muster sein, dass nicht ganz so diffus ist, wie das erste blaue auf der Freespace-Seite. Ciao |
|||||
Reth
Nutzer
22.02.2008, 15:42 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung Zitat: Bin in Sachen Grafikalgorithmen ebenso Unerfahren wie bei den mathematischen Grundlagen. Welche Algorithem eignen sich denn zur Generierung von Grashalmen? Mit einer Grammatik kommt man da nicht unbedingt weiter, denke ich. Zitat: Allerdings! Klingt mal einfach! Ciao |
|||||
Reth
Nutzer
22.02.2008, 14:58 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung Zitat: Sorry, habe mir den Code von PerlinFX nicht angesehen. Was meinst Du mit alog? Deine Routine, die aus Ellipsen Röhren macht (oder nen Logarithmus)? Was ist der Grund, ein Perlin Noise Muster für die Länge zu nehmen (oder funktioniert selbiges einfach nur gut in dem Fall)? Und wie funktioniert das Zusammenspiel zw. Grashalm, Perlin Noise Muster und Grasfarbe? Wird die dann auch aus dem Muster gewonnen? Für Bumpmapping und Displacement Map muss ich mich erst noch entsprechend einlesen/aufschlauen. Ciao |
|||||
Reth
Nutzer
21.02.2008, 15:01 Uhr [ - Direktlink - ] |
Thema: OWB 1.10 unter OS4 Classic
Brett: Amiga, AmigaOS 4 Zitat: Und wieviel ist davon noch frei, wenn OWB hängen bleibt? |
|||||
Reth
Nutzer
21.02.2008, 13:32 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung Zitat: Ich weiß, auf den hab ich auch angespielt. Das mit der Grammatik ist sehr einleuchtend allerdings fehlt mir hier auch die Erfahrung, wie man von dieser auf einen Baum (Bild) kommt. Da wird dann der Teil mit Deinen Röhren aus Ellipsen interessant, doch die Zuordnung von Pixeln aus einem Patternbild auf die Röhrenoberfläche hört sich wieder nach üblen Berechnungen an, ebenso die Projektion von 3D->2D Iso. Zitat: Denk ich mir (s.o), drum meine Frage nach Stichwörtern, betrifft auch die zugrunde liegende Mathematik! Und wie sieht es mit Dingen wie Gräsern, Geröll, Sumpf etc. aus? Gibt es da auch was in die Richtung? Ciao |
|||||
Reth
Nutzer
21.02.2008, 13:08 Uhr [ - Direktlink - ] |
Thema: os 4.0 installation geht nicht
Brett: Amiga, AmigaOS 4 @PeaBrain: Wie gesagt: Probiers mal mit nem anderen Monitor und lass uns das Ergebnis wissen! Ciao |
|||||
Reth
Nutzer
21.02.2008, 11:08 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung @Der_Wanderer: In welche Richtung (Stichwörter) muss man denn suchen, wenn man solche Sachen wie Baumstämme, Bäume, Sträucher mit entsprechenden Schatten rendern lassen möchte? Die Sachen machen zwar ne Menge Spass zu pixeln, aber darin bin ich nicht sehr gut! Ciao |
|||||
Reth
Nutzer
21.02.2008, 09:37 Uhr [ - Direktlink - ] |
Thema: OWB 1.10 unter OS4 Classic
Brett: Amiga, AmigaOS 4 @julius: Hm, komisch! Das Problem habe ich erst, wenn ich besagten Thread im OWB öffnen möchte! Wenn ich dann auf den WB-Screen umschalten möchte, friert das System ein. Wieviel Speicher hast Du denn? Denke, dass es am Hauptspeicher liegt (zu wenig). Ciao |
|||||
Reth
Nutzer
20.02.2008, 13:10 Uhr [ - Direktlink - ] |
Thema: OWB 1.10 unter OS4 Classic
Brett: Amiga, AmigaOS 4 @julius: Also ich habe mir OWB sowie die beiden so-Archive von Jörgs Seite geholt, entpackt und installiert. Die Schriften usw. hatte ich bereits von einer älteren OWB-Version installiert (weiß gerade nicht, ob die im aktuellen OWB-Archiv mitkommen). Bei mir aufm A4000 läuft er, hängt sich aber auf bzw. stürzt ab, wenn ich z.B. in meinen Thread "Prozedurales Programmieren" gehen will. Ciao |
|||||
Reth
Nutzer
19.02.2008, 22:46 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung Danke! Nun hab ichs auch gerafft. Irgendwie muss man ja aber auch von dem Bsp. der Interpolation des 3-dimensionalen Pixels in dem von mir verlinktem Artikel auf Dein Codebsp. oben kommen, ohne es in Reihen aufzudröseln. Muss ich noch probieren! Zitat: 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: Das hat mir gefehlt, danke! Dieser Zwischenschritt. Damit sollte ich ja durch Einsetzen auf die Berechnung der Gewichtungen kommen. Muss ich auch noch aufm Papier ausprobieren! Da sieht mans ja! Ich brauch einige Zwischenschritte mehr, um den Kram zu kapieren. Mir sind solcherlei Dinge nicht so selbstverständlich klar, weil ich damit seit knapp 10 Jahren absolut nichts mehr am Hut habe! Vielen Dank nochmals! Ciao |
|||||
Reth
Nutzer
19.02.2008, 22:14 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung @Der_Wanderer: Nochmals Danke! Wie kommt man denn auf den Algorithmus, der einem für z.B. das (8x8)-Bild einen Pixel aus dem (2,2)-Bild ermittelt? Habe mir die Freespace-Seite noch ein paar mal angesehen, finde aber nicht, dass dort die lineare Interpolation erklärt wird, sondern einfach nur vorgesetzt (á la hier ist die Formel). Dagegen ist sie hier: Lineare Interpolation wirklich erklärt (also hergeleitet). Dasselbe gilt für die Cosinus-Interpolation. Allerdings bin ich immer noch zu blöd die dort erklärte Lineare Interpolation in Deinem Code wiederzufinden, also die Formel a*(1-x) + b*x für die Punkte a und b, sowie den dazwischenliegenden Dezimalteil x (ich weiß, dass sie da ist, liegt an der 2. Dimension, die dazu kommt). Immerhin hab ich aber nun verstanden, wieso man die 4 angrenzenden Pixel betrachtet! Geht halt leider alles seeeehhhhrrrr laaaaaannnngggsaaaammm bei mir, noch dazu mit dem jahrelangen Abstand zu solcherlei Dingen! Ciao |
|||||
Reth
Nutzer
19.02.2008, 13:00 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung Zitat: Wenn der Punkt in einem Kästchen liegt, dann gibt es die 4 Ecken/Kanten des Kästchens, in dem der Punkt liegt, falls Du die meinst. Das wäre dann aber links oben (x-1,y-1), rechts oben (x+1,y-1), links unten (x-1,y+1) und rechts unten (x+1,y+1)?! Wenn ich mir nun ein Kästchen als Pixel vorstelle, so ist es (außer am Rand) aber von 9 anderen Kästchen (Pixeln) umgeben. Hab ich nun nen krummen x-Wert wie 1,25 habe, dann liegt der zu 0,25 im 2. Pixel der betrachteten Zeile, daher dachte ich, dass ich nun das 2. Pixel und alle umliegenden 8 für die Interpolation brauche! (Duck) Ciao |
|||||
Reth
Nutzer
19.02.2008, 09:00 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung Vielen Dank! So versteh ich das auch. Noch 2 kurze Verständnisfragen: Zitat: Gibt es einen Grund, warum nur die darunter und rechts daneben liegenden Pixel betrachtet werden und nicht alle umliegenden? Zitat: Das gilt dann auch für (2,1), oder (wenn man bei (0,0) beginnt)? Ciao |
|||||
Reth
Nutzer
18.02.2008, 19:20 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung Zitat: Konnte dort aber nicht entnehmen, warum man bei der linearen und Cosinusinterpolation die 4 benachbarten Pixel betrachtet und auch nicht, was denn dann als 3. Parameter an die Interolationsfunktion gegeben wird, weil ich mir nicht erklären konnte, wo bei ganzzahligen Koordinaten auf einmal die Dezimalanteile zw. 0 und 1 für die Interpolationsfunktion herkommen sollen! So ganz ist mir das immer noch nicht klar, trotz Deiner tollen Veranschaulichungen, muss mich noch weiter damit beschäftigen! Wie gesagt werden dort bei der Glättung ja alle Nachbarn betrachtet. Zitat: Und hier hab ich eben nicht begriffen, welches Pixel an der Koordinate 5.2 liegen soll. Aus Deinem Bsp.-Code geht das eher hervor, denke ich. Man betrachtet z.B. im gewünschten Zielbild (z.B. 8x8) den Wert (5,0) und ermittelt im aktuellen Quellbild (z.B. 2x2) den entsprechenden Wert dazu. Und nach Deinem Code (source_x = dest_x * source_width/dest_width) bekommt man dann für (5,0) z.B. 1.25 raus. Mein Problem ist, das zwar schon alles dasteht, ich aber immer noch nicht alles verstanden habe, muss es mir noch selbst erklärbar machen und versuchen nachzuvollziehen, was da passiert. Hab da nicht so den Zugang zu solchen Sachen. Ciao |
|||||
Reth
Nutzer
18.02.2008, 18:01 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung Vielen Dank für Deine Antwort! Zitat: Das war z.B. eine Information, die mir bisher gänzlich gefehlt hat und die ich bisher weder aus einem Posting (einschließlich Deinen) noch aus Wikipedia oder Tutorials entnommen habe (bzw. deren Warum)! Da hieß es immer nur die benachbarten Punkte (das können bis zu 8 sein). Auf der Freespaceseite werden zum Glätten sogar alle 8 Punkte betrachtet, wenn ich das richtig verstanden habe! Gibt es irgendwo einen Wikieintrag o.ä., in dem das Warum und wie erklärt wird (z.B. die Gewichtung der umliegenden Pixel)? Zitat: Danke, das wusste ich auch noch nicht (wäre mir auch nicht so schnell eingefallen!)! Ciao |
|||||
Reth
Nutzer
18.02.2008, 14:59 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung Zitat: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: So hab ichs ja auch im Bsp.-Code gemacht, nur mit Blauwerten. Zitat: Das hab ich auch noch hinbekommen! Zitat: Das hab ich auch verstanden, konnte es aber nicht umsetzen! Zitat: Jetzt ist mir die Persistenz auch klarer, die hatte ich vorher nur als Vereinfachung der Abhängigkeit zw. Amplitude und Frequenz der aufeinanderfolgenden Noise-Funktionen verstanden. Zitat: Das waren ja auch meine Fragen: Wird nur das Mittel der links und rechts daneben liegenden Punkte genommen, oder aller umliegenden Punkte (wie auf der freespace-Seite)? Zitat: Muss ich dann für das 2x2 Bild 2 Mal interpolieren, immer mit einer Verdoppelung (also erst einmal auf 4x4 und das dann auf 8x8)? Zitat: So funktioniert also die Aneinanderreihung. Aber nicht im Bsp. auf der Freespace-Seite, da dort für jeden Punkt gleich alle Funktionen durchlaufen werden! Zitat: Ich trau mich ja gar nicht mehr zu fragen, wie man dann das mit dem Gras macht, oder Sachen wie auf dem letzten Bild, bzw. auf dem ersten (PN mit anderen Farbwerten, aber nur in bestimmten nicht-rechteckigen Regionen?)! Ciao |
|||||
Reth
Nutzer
18.02.2008, 14:31 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung @Madcat: Danke. Stimmt! Wenn man keine Gewichtung braucht, dann reicht es den Anteil jedes Pixels am Farbwert des Endresultates als gleich zu betrachten. Was mir noch eingefallen ist, zu meiner Frage, wieso in dem Bsp. alle Noise-Funktionen für jeden Punkt auf einmal durchlaufen werden: Wird damit dann nicht schon diese Übereinanderlegung der Bilder erreicht? Ein weiterer Gedanke meinerseits war, dass der Gesamtcode der 2-dimensionalen Funktion, wenn man ihn nur mit normalen ganzzahligen Koordinaten (für Pixel) füttert, dieser ja nie wirklich interpolieren muss, da die Interpolationsfunktion pro Aufruf nur den ersten oder 2. Wert zurückgeben würde. Heißt das dann, ich bekomme das Ergebnis des letzten Bildes (also der übereinandergelegten Bilder) auch, wenn ich jeden Pixel einzeln eingebe, alle Noise-Funktionen drüberlasse und das Ergebnis ausgebe (muss ich mal probieren, kanns aber kaum glauben)? Dann braucht man ja nix zu interpolieren!? Denn das ist mir noch nicht so ganz klar, wie das genau funktionieren soll (s. mein Codebsp., dort wird bei jedem Schritt von einem y-Wert zum nächsten für alle zwischenliegenden Werte interpoliert und der t-Wert in Abhängigkeit der Schrittweite gewählt - entsprechend jeweils für alle x-Werte; und das Ergebnis sieht übel aus!)! Ciao |
|||||
Reth
Nutzer
18.02.2008, 12:46 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung @Madcat: Stimmt! Jetzt müsst ich "nur" noch meinen anderen Fragen geklärt bekommen! Habe momentan gar keinen Ansatzpunkt mehr! Ciao |
|||||
Reth
Nutzer
17.02.2008, 22:25 Uhr [ - Direktlink - ] |
Thema: OWB 1.10 unter OS4 Classic
Brett: Amiga, AmigaOS 4 Zitat: Versteh ich gerad nicht! Welche sind das denn, außer Fonts? Bzw., was meinst Du damit (bin gerade hirnmäßig eher am Abnippeln scheint mir, wenn ich mir meine anderen Fragen-Threads so ansehe)? Zitat: Blöde Frage: Welches sind die Core-Fonts? Meinst Du hier das OWB-Verzeichnis? Vor Windows sitze ich gerade, habs mit dem Rechner gekauft und daher auch das Recht (m. Erachtens) Teile davon woanders einzusetzen! Die recoverables stören weniger, der System-Freeze dagegen sehr! Ciao |
|||||
Reth
Nutzer
17.02.2008, 22:21 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung Also ich geb bald auf, da es mich langsam wütend macht, dass ich offenbar total aufm Schlauch stehe! Tutorials hin oder her, entweder ham die noch Fehler, oder (wahrscheinlicher) raff ichs nicht! Hier mal meine Vorgehensweise: 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); } } } } } } } } Hier noch die Interpolationsfunktion, die ist abgeschrieben: 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); } Das seltsame an dieser ist, dass laut diesem Beitrag hier: Cosinus Interpolation Die Funktion nur Werte zw. 0 und 1 zurückliefern sollte (was ich nachvollziehen konnte). Ich bekomme aber bei negativen Eingaben (wenn die eingegebenen Noise-Werte negativ sind) auch negative Rückgabewerte! Das verstehe ich nun wiederum nicht! Hier die Noise-Funktion, auch abgeschrieben: 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; } Was mach ich denn bitte alles falsch? Bekomme alles Mögliche raus, nur nicht die Ergebnisse wie auf den Bildern! Mir fehlt hier komplett die Ahnung, wie man das Verfahren richtig anwendet und wie es genau funktioniert! Wenn ich mehr als einen Durchlauf mit entsprechender Persistenz, Frequenz und Amplitude mache, werden die Muster sehr regelmäßige dünne Linien! Bitte um erklärende Antworten, auch für meine darüber liegenden Post! Würde sehr gern verstehen, was da vor sich geht und wie! Ciao [ Dieser Beitrag wurde von Reth am 17.02.2008 um 23:10 Uhr geändert. ] |
|||||
Reth
Nutzer
17.02.2008, 21:17 Uhr [ - Direktlink - ] |
Thema: OWB 1.10 unter OS4 Classic
Brett: Amiga, AmigaOS 4 Läuft bei mir 1A, seit dem ich auch die beiden anderen Archive mit den Shared Objects von Jörgs Seite installiert hatte! Allerdings blitzen bei Version 1.10 öfter gelbe recoverable Alerts auf und sie bleibt irgendwann bei mir hängen und friert das System ein (weiß noch nicht, ob das passiert, wenn der Speicher ausgeht)! Daher: Vielen Dank Jörg! Super Arbeit! Ciao |
|||||
Reth
Nutzer
17.02.2008, 01:11 Uhr [ - Direktlink - ] |
Thema: Prozedurales Texturieren
Brett: Programmierung @Der_Wanderer: Danke schön! Ich dachte, es heißt prozedural, weil die Texturen berechnet werden und nicht aus vorgegebenen Grafiken übernommen? Wie addiere ich denn pixelweise die Bilder auf? Wenn ich die 3 Bilder habe und bei allen dreien (nach Interpolation) an einer Position ein Noise-Wert (meinetwegen grau auf schwarzem Hintergrund) ist, wie addiere ich die dann? Mal rein von den Farbwerten her gesehen (wenn mein Maximum bei 255 liegt), was mach ich, wenn ich die 3 Grauwerte addiere (also Weißanteil) und dann bei >255 lande? Aber bei mir muss man glaub ich viel weiter vorn anfangen und gaaaanz langsam vorgehen, v.a. weil die ganze Mathe verschütt gegangen ist. Nach stundenlangem Lesen und Grübeln über die Interpolation hier: Interpolation bin ich zu folgendem grundsätzlichen Ergebnis gekommen: Für zwischenliegende Punkte werden die Noise-Werte der interpolierten Werte (interpoliert zw. den beiden angrenzenden Punkten) verwendet und nicht die Noise-Werte der Punkte selbst! Also wenn Noise-Werte für die Punkte (1,1) und (3,1) direkt berechnet wurden, wird für (2,1) der Noise-Wert des Interpolationsergebnisses mit Startwert (1,1) und Endwert (3,1) verwendet! Stimmt das erstmal so, oder ist da immer noch ein Denkfehler drin? Oder wird für zwischenliegende Punkte der interpolierte Wert der beiden Noise-Werte der benachbarten Punkte gebildet? Oder muss ich bei 2-dimensionalen Punkten mehrfach über alle benachbarten Punkte (also in x- und y-Richtung) interpolieren? D.h. für einen Punkt in der Ebene alle 8 benachbarten Punkte betrachten? Und zu guter Letzt: Wie interpoliere ich denn z.B. das 2x2 Feld auf 8x8, wenn man doch immer zwischen 2 Punkten interpoliert? Setze ich dann die Punkte aus dem 2x2 an die Ecken des 8x8 und interpoliere zwischen ihnen? Allerdings ist mir nicht so klar, wie der 2-dimensionale Algorithmus hier funktioniert: 2-dimensional Perlin Noise Pseudocode , da er ja bei jedem Punkt versucht zu interpolieren! Ist es da so, dass ich mit diesem Algo, wenn ich nur jeden 2. Punkt betrachte den Interpolations-Aufruf für zwischenliegende Punkte mit 0.5 als dritten Parameter mache? Blick da noch nicht ganz durch! Und wieso betrachtet der Algorithmus immer nur die drunter und rechts neben dem aktuellen Punkt liegenden Punkte? Und wieso läuft er für jeden Punkt über alle Noise-Funktionen (hab ich glaub schon mal gefragt)? Ciao [ Dieser Beitrag wurde von Reth am 17.02.2008 um 17:05 Uhr geändert. ] |
|||||
|
Impressum |
Datenschutzerklärung |
Netiquette |
Werbung |
Kontakt
Copyright © 1998-2024 by amiga-news.de - alle Rechte vorbehalten. |