******************************* * * * Text aus der Serie * * (c) GERMAN (Copyright) * * RHEIN-MAIN-SOFT * * Oberursel * * * ******************************* ************** * DBW_RENDER * ************** V2.0 von: William T. Baldridge 2650 Sherwood Lane Pueblo, CO 81005 und: David B. Wecker 115 Palm Springs Drive Colorado Springs, CO 80921 Deutsche Übersetzung: (C) RHEIN - MAIN - SOFT Copyright (c) 1987, William T. Baldridge alle Rechte vorbehalten Urheberrecht der deutschen Übersetzung: Oliver Burghard Dieses Dokument (Anm. des Übersetzers: die englische Orginalausgabe) gehört zum Lieferumfang des DBW_Render-Programmes. DBW_Render wird mit der Hoffnung vertrieben, daß es Ihnen nützlich sein wird, allerdings kann keinerlei Garantie gegeben werden. Weder die Autoren, noch die Vertreiber können die Verantwortung für die Konsequenzen des Gebrauches dieses Programmes oder die korrekte Ausführung der beabsichtigten Optionen oder irgendeiner Funktionsweise übernehmen, außer dies wird schriftlich festgelegt. Wir beziehen uns hiermit auf die "DBW_Render General Public Licence" im Anhang. Es wird hiermit jedem die Erlaubnis erteilt, DBW_Render zu kopieren, zu verändern und weiterzuverteilen, jedoch nur unter den Bedingungen, wie sie in der "DBW_Render General Public Licence" beschrieben sind. Eine Kopie dieser Lizenz wird Ihnen mit diesem DBW_Render Programm bereitgestellt, sodaß Sie sich darin über Ihre Rechte und Pflichten informieren können. Dieses sollte sich in einem File namens "COPYING" befinden. Darüberhinaus müssen sich die Copyright-Notiz und dieser Artikel auf allen Kopien befinden. Es wurde versucht, die englische Orginalausgabe nicht nur wörtlich zu übersetzen, sondern diese auch, so weit es mir möglich war, zu überarbeiten. Dabei wurden einige Fehler im Orginal entdeckt. Die Autoren haben anscheinend das Programm selbst seit der Ausgabe dieser Beschreibung mehrfach überarbeitet, jedoch eine Anpassung dieser Anleitung unterlassen. Oft stimmte deshalb die Ausführung des Programmes nicht mit der Anleitung überein. Ich hoffe, die meisten Fehler gefunden zu haben. Sollten Sie noch welche finden, dann können Sie diese Anleitung gerne korrigieren, bevor Sie sie weiterverteilen. Außerdem wäre ich jedem dankbar, der mir diese Korrektur zukommen ließe. Es kann natürlich keine Garantie für die korrekte Übersetzung dieser Bedienungsanleitung übernommen werden. Diese Anleitung darf von jedem vervielfältigt und weiterverbreitet werden, vorausgesetzt er beläßt diesen Abschnitt und die Urheberrechtshinweise des Übersetzers unverändert in der Kopie. === Inhaltsverzeichnis === Hintergrund Informationen - Was beinhaltet dieses Programm? Neue Merkmale - Was wurde seit V1.0 hinzugefügt? Bedienungsanleitung RAY - Wie bediene ich den Ray Tracer? Erzeugen eines .INP files - Was gehört alles in ein input-file....der schwierigste Teil === Hintergrund Informationen === Das DBW_Render-Programm verwendet einen Algorithmus, der verteilte Lichtspur Berechnung genannt wird. Zusätzlich zur Lösung des Problemes der verdeckten Oberflächen sollte ein Ray-Tracing Programm (normalerweise) Schatten- und Beleuchtungsberechnungen exzellent (d.h. äußerst realistisch) beherrschen. Dieses Programm ist mit dem MANX-Aztec C Compiler geschrieben und übersetzt worden und läuft auf jedem AMIGA. Das RAY-Programm kann aus fünf primitiven, geometrischen Objekten Bilder erzeugen: Kugeln, Parallelogramme, Dreiecke, "Super-Quader" und flachen kreisförmigen Ringen. Einige Dinge, die das Programm beherrscht, sind: Bestimmung der exakten Schatten, die durch willkürlich gezeichnete Objekte geworfen werden, welche wiederum von willkürlichen Lichtquellen beleuchtet werden. Diffuse und ordentliche Reflexionen (wobei der Grad des Glanzes und der Politur ebenfalls beliebig gewählt werden kann). Die rudimentäre (verstümmelte) Modellierung des von-Objekt-zu-Objekt diffus reflektierten Lichtes ist ebenfalls implementiert, sodaß neben anderen Dingen die Beeinflussung der Oberflächenfarbe nebenstehender, kontrastierender Objekte genau simuliert werden kann. Spiegelreflexionen, einschließlich der Bestimmung des Grades der Weichzeichnung und Exaktheit des Spiegels. Strahlenbrechung und Lichtdurchlässigkeit (verwandt mit der mikroskopischen Weichzeichnung, ähnlich der Oberfläche von geschliffenem Glass). Zwei Arten von Lichtquellen: direktes, gerichtetes Licht (parallele Strahlen mit Ursprung im Unendlichen) mit konstanter Intensität und kugelartigen Quellen (wie Glühbirnen, die Halbschatten als eine Funktion von Radius und Entfernung erzeugen), bei denen die Intensität mit dem Gesetz des umgekehrten Quadrates berechnet wird (doppelte Entfenung = 1/4 Intensität). Fotografische Schärfentiefe. Wenn z.B. die virtuelle Kamera auf ein bestimmtes Objekt in der Scene scharfgestellt wird, dann kann man durch die Veränderung des Öffnungswinkels der virtuellen Optik die Scharfzeichnung der vorder- und hintergründigen Objekte bestimmen. (Bei gleichzeitiger Veränderung der Entfernung zum Objekt bleibt dann der Bildausschnitt sogar gleich. Wie in der Fotografie eben.) Feste Oberflächentexturen. Normalerweise besitzt ein beliebiges Objekt konstante Eigenschaften (wie z.B. die Farbe) über die gesamte Oberfläche, was dann jedoch oft unrealistisch aussieht. Diese festen Oberflächentexturen sind nun eine Möglichkeit, diese Eigenschaften mit mathematischen Mitteln zu verändern, und den Gegenständen damit ein natürliches Aussehen zu geben. Momentan besitzt das Programm die mathematischen Gesetze zur Modellierung von Holz, Marmor, Ziegelstein, mit Schnee bedeckten Scenen, Wasser (einschließlich willkürlicher Wellen), Kieselsteinen und einigen abstrakten Dingen, wie Mischfarben und -texturen. Fractals. Im Programm ist eine Berechnungsmethode implementiert, die unter dem Namen "rekursive Dreiecks-Unterteilung" bekannt ist und die alle Arten von natürlich aussehenden Oberflächenstrukturen (wie z.B. gebrochener Fels, Berge, usw) erzeugt. Der Charakter der Fractal-Oberfläche (Grad der Detaillierung, Rauhigkeit, usw) wird durch die ins Programm eingespeisten Parameter bestimmt. Sobald das RAY-Programm gestartet wird, liest es ein Input-File (.INP) ein, daß nun von einem "Preprocessor" compiliert wird (RAY0). Dieser verwandelt nun die Hochsprache des Input-Files in ein Kommandosprache File um (.DAT), das eine geometrische Beschreibung der zu berechnenden Scene, der gewünschten Lichtverhältnisse, Kameraparameter, usw. enthält. Dann rechnet das Programm (RAY1) eine lange Zeit und schreibt jede einzelne gescannte Linie nach deren Berechnung auf Diskette. Dieses File (.TMP) muß schließlich noch in einem eigenen Prozeß (RAY2) in ein IFF/ILBM Bild mit bis zu 4096 Farben umgerechnet und in ein extra File geschrieben werden (.ILBM). Alle diese Files sind Standard IFF/ILBM Files und können mit dem mitgelieferten RAY3 Programm angesehen werden. Zusätzlich können diese Bilder natürlich von jedem normalen Grafik-Programm (wie z.B.DPaint) eingelesen und weiterverarbeitet werden. Andere Grafikprogramme können sogar die viel komplexeren HAM-Bilder mit 4096 Farben verarbeiten (wie z.B. PRISM). Alles in allem umfaßt das gesamte DBW_Render-Packet an die 9500 Zeilen C-Sourcecode. Dies ist eine komplette Überarbeitung des DBW_Render V1.0 und benötigte über 7 Monate Bearbeitungszeit. === Neue Merkmale === RAY : - Ein neues Hauptprogramm, das alle anderen Module startet - Konsequentes Anwender-Hauptprogramm - Erlaubt die Eingabe vieler Parameter auf einmal RAY0: - Neue Hochsprache bei der Programmierung des Input-Files - 2 und 3 dimensionaler Text werden unterstützt - Generiert Rotationsobjekte (Konus, Zylinder...) - Generiert Translationsobjekte (Quader...) - Beliebige Polygone - Vollkommen verschachtelte Makros (bis zu 10 Ebenen) - Zusammengesetzte Objekte (über Makros) - Include-Files (Einbinden von Files in das Programm) - Volle Unterstützung aller neuen RAY1 Möglichkeiten - Ausdrucksvolle Fehlermeldungen RAY1: - Neues Grundobjekt: der "Super-Quader" - Eine neue Textur: Ziegel aus IFF-Bildern - Bilder mit bis zu 1024x1024 Punkten (Minimum 8x8) - Bis zu 24 bit pro Bildpunkt (16 Millionen Farben) - Zwei "Skizier"-Modi (scetch) zur schnellen Bilderzeugung - Viele Beschleunigungen und Fehlerbeseitigungen - Eine noch kompaktere Präsentierung der Objekte (Speicher!) - Das "Pixel-Raten" wurde für schönere Bilder entfernt RAY2: - Gemittelter Farbwahlalgorithmus für schönere Farben - KD-Baumstruktur zur Unterstützung des Fardbwahlalgorithmus - "Overscan"-Bilder werden unterstützt - Die Postscript-Ausgabe (Protokollierung) kann nun direkt in ein File erfolgen - Viele Beschleunigungen (vollkommen Überarbeitet) RAY3: - Komplette Überarbeitung des "DISPLAY"-Programmes (Anzeige) - Unterstützt "Overscan"-Bilder === Bedienungsanleitung RAY === A C H T U N G !!! Arbeiten Sie nur mit einer Back-Up Diskette!! Sie sollten nie mit den Orginaldisks arbeiten! Sobald Sie ein Input-File vor sich haben (beschrieben weiter hinten im Kapitel "Erzeugen eines .INP Files"), können Sie den Ray Tracer starten. Vergewissern Sie sich jedoch vorher, daß Sie auf der Diskette, auf die Sie Ihre erzeugten Files abspeichern wollen, genügend Speicherplatz vorhanden ist. Denn, wie Sie sich vielleicht erinnern, benötigt die Ausgabe des Ray Tracers für ein vollständiges Bild an die 200.000 Bytes bzw. 400 Blocks. Wir empfehlen jedoch NICHT, die Ausgabe auf die RAM-Disk umzuleiten: denn sollte aus welchen Gründen auch immer Ihr Betriebssytem einmal abstürzen, ist Ihre gesamte Arbeit verloren. Zusätzlich sollten Sie Ihren Speicherplatz zuvor mit STACK auf mindestens 30.000 erweitern! Schreiben Sie also vor dem Start: stack 30000 Am Besten ist es, Sie formatieren vor dem Start eine leere Diskette und kopieren sich mit dem COPY-Befehl folgende Files darauf: RAY - Das Hautprogramm (Startet alle anderen) RAY0 - Der .INP File Compiler RAY1 - Der .DAT File Ray Tracer RAY2 - Der .TMP File Postprozessor RAY3 - Die .ILBM File Ausgabe RAY.KEY - Das Schlüsselfile (damit identifiziert Sie RAY als legalen Anwender) #?.INP - Ein beliebiges Input File Das Hauptprogramm, genannt RAY, startet also alle Unterprogramme des Ray Tracers selbstständig. Wenn Sie z.B. eingeben: 1> ray -n ring dann werden Sie folgende Meldungen auf dem Bildschirm erhalten: ray0 ring.inp ring.dat ray1 ring.dat ring.tmp ray2 -o ring.ilbm ring.tmp Die "-n" Option sagt dabei RAY, daß es Ihnen zeigen soll, was es tun würde, wenn Sie es in dieser Weise (ohne -n) gestartet hätten. Der "-n" Schalter ist also eine komfortable Möglichkeit, sich erst einmal anzusehen, ob das Programm auch tatsächlich das ausführt, was man von ihm erwartet. In diesem Fall würde RAY also zuerst mit dem Unterprogramm RAY0 das ring.inp File in ein ring.dat File kompilieren. Dann würde es RAY1 starten (Berechnung des Bildes) und schließlich mit RAY2, dem Postprozessor, ein ILBM/IFF Bild erzeugen und dies im ring.ilbm File ablegen. Wenn Sie nun das Beispielfile ring.inp nehmen (bitte vorher auf Ihre Arbeitsdiskette kopieren) und RAY starten, werden Sie folgendes angezeigt bekommen (die deutsche Übersetzung steht in ``-Anführugsstrichen): 1> ray ring RAY v2.0 870801 (C) 1987 W. Baldridge - all rights reserved RAY0 v2.0 870801 (C) 1987 W. Baldridge - all rights reserved RAY1 v2.0 870801 (C) 1987 W. Baldridge - all rights reserved `Prg.` `Version` `alle Rechte vorbeh.` Building object extents `Analysiert Umfang des Objektes` Building extent tree `Baut die Baumstruktur auf` Using 1 extents for 1 objects `Anzahl der Einzelstrukturen und der Objekte` Rows 0 to 40 of 40, width of 40 mode 0, bpp = 4 * 3 `Anz.d.Reihen` `Breite` `Modus` `Bitplanes / Pixel` Row 0: ........................................ `Berechnete Reihe` Average distribution count = 1.00, max = 1 `Zähler der durchschnittlichen Verteilung` Total pixels computed = 1600 `Insgesammt berechnete Bildpunkte` Total time used = 58 seconds `Rechenzeit total` Ray intersect runs = 2548 `Anzahl der Berechnungen der Lichtstrahlüberschneidungen` Max intersects for 1 ray = 1 `Maximale Überschneidungen für eine Strahl` Avg intersects per pixel = 1.59 `Durchschnittliche Überschn. pro Bildpunkt` Total sorts = 0 `Anzahl der Sortierroutinen` Maximum stack size = 2412 `Maximal benötigter Speicher` RAY2 v2.0 870801 (C) 1987 W. Baldridge - all rights reserved Building a color histogram: `Aufbau des Farbhistogrammes` Row 0: ........................................ Used 3 colors out of a possible 4096 `Anzahl der verwendten Farben` Depth 0, ID 0, Typ 2, Cnt 1600, Med 8 Depth 1, ID 1, Typ 4, Cnt 652, Table[ 0] = 01c Depth 1, ID 2, Typ 1, Cnt 948, Med b Depth 2, ID 3, Typ 2, Cnt 333, Table[ 1] = e97 Depth 2, ID 4, Typ 4, Cnt 615, Table[ 2] = fdc Row 0: ........................................ Row 0: ........................................ Wenn Sie nur den Compiler starten wollen (Phase 0), könnten Sie schreiben: 1> ray -o ring.dat ring.inp Der "-o" Schalter sagt RAY, an welcher Stelle es zu stoppen hat. Hier nimmt sich also ray ein .INP File und compiliert es in ein .DAT File. Wenn Sie nun nur die Phase 1 (die Berechnung des Bildes) ausgeführt haben wollen, schreiben Sie: 1> ray -o ring.tmp ring.dat Um nur die letzte Phase 2 laufen zu lassen, schreiben Sie: 1> ray -o ring.ilbm ring.tmp RAY versucht also grundsätzlich zunächst einmal zu erfahren, was Sie ausgeführt haben wollen, um dies anschließend zu tun! Hier nun noch ein paar Beispiele (wir verwenden hierbei den -n Schalter): 1> ray -n -o ring.tmp ring.inp ray0 ring.inp ring.dat ray1 ring.dat ring.tmp 1> ray -n r1 r2 r3 ray0 r1.inp r1.dat ray0 r2.inp r2.dat ray0 r3.inp r3.dat ray1 r1.dat r1.tmp ray1 r2.dat r2.tmp ray1 r3.dat r3.tmp ray2 -o r1.ilbm r1.tmp r2.tmp r3.tmp Das zweite Beispiel oben zeigt die Möglichkeit auf, drei Einzelteile eines Bildes zu nehmen und RAY die Anweisung zu geben, alle drei zu berechnen und anschließend diese in einem Bild zusammenzufassen. Nun stellt sich natürlich die Frage: "Wie kann ich mir das Ergebnis ansehen?" Da RAY immer nach Anhaltspunkten sucht, was Sie denn gerne von ihm ausgeführt haben wollen, müssen Sie RAY nur wieder das Richtige befehlen. Um z.B. das Bild ring.ilbm betrachten zu können, gibt es zwei Möglichkeiten: 1> ray ring.ilbm oder 1> ray -s ring Beim ersten Beispiel erkennt RAY die .ilbm Extension und weiß damit, daß Sie ein Bild sehen wollen. Beim zweiten Beispiel befehlen Sie RAY mit dem "-s" Schalter, daß es ein Bild zeigen soll. Diese Art der Eingabe ist vor allem dann sinnvoll, wenn Sie sich mehrere Bilder hintereinander ansehen wollen und dabei nicht immer die Extension .ilbm eingeben wollen: 1> ray -s ring sphere quad triangle superq Der Wechsel von einem Bild zum nächsten erfolgt dabei durch Drücken der -Taste. Nun fassen wir mal alle Schalter zusammen, auch die, die wir noch nicht näher erklärt haben: -c - Schaltet die Komprimierung des .ilbm Files aus. Das Bild braucht dann allerdings mehr Speicherplatz. (Normal: Eingeschaltet) -d Tiefe - Verwendet "depth bit planes". Damit kann man (depth) die Anzahl der zu verwendenden Farben einstellen. Folgende Einstellungen sind mgl.: -d 6 = 4096 Farben (HAM-Modus) (Normal) -d 5 = 32 Farben -d 4 = 16 Farben -d 3 = 8 Farben -d 2 = 4 Farben -d 1 = 2 Farben -l - Schaltet den Interlace-Modus im .ilbm File aus (Normal: Eingeschaltet) -n - Programmausführung wird nur angezeigt -o Filename - Der Name des Files, bei dem das Programm enden (outfile) soll (z.B. -o ring.tmp) -p Filename - Schreibt ein Postscriptfile unter dem (psfile) angegebenen Filenamen. -s - Anzeigen des ILBM-Bildes (show) Dazu noch ein Beispiel: 1> ray -o ring -p ring.ps -d 5 -l -c -n ring ring.ilbm ray0 ring.inp ring.dat ray1 ring.dat ring.tmp ray2 -o ring.ilbm -d 5 -p ring.ps -l -c ring.tmp ray3 ring.ilbm Das File ring wird also compliliert und anschließend ein IFF/ILBM Bild mit 5 Bitplanes (32 Farben), ohne Interlace und unkomprimiert erstellt; außerdem wird ein Postscriptfile namens ring.ilbm ausgegeben. Zusätzlich wird es nach der Erstellung auf dem Bildschirm angezeigt (dank des Kommandos ring.ilbm am Ende der Eingabezeile). Sollten Sie das "ring" Beispiel oben ausprobiert haben, versuchen Sie mal mit folgender Eingabe eine Nachbehandlung: 1>ray -d 2 -l ring.tmp ring.ilbm Dies stellt Ihnen einen doppelt hohen Ring zur Verfügung (Interlace ausgeschaltet) und verwendet dabei nur 2 Bitplanes (anstatt von 6). Sie werden jedoch keinen Qualitätsunterschied feststellen können, da daß Bild eh nur 3 Farben verwendet. === Erzeugen eines .INP Files === Nun also zum schwierigsten Teil: dem Inhalt des geschriebenen Input-Files. Dieses File ist ein standartisiertes ASCII Textfile mit der in Anhang A beschriebenen Syntax. Zunächst etwas grundsätzliches: - Alle Farbwerte enthalten 3 Zahlen im Bereich von 0 bis 1. Die einzelnen Farbkomponenten müssen dabei in der folgenden Reihenfolge erscheinen: ROT, GRÜN, BLAU. - Alle Winkel werden in 360-er Gradeinteilung angegeben. - Alle Positions- und Richtungsangaben müssen als 3 aufeinanderfolgende Werte angegeben werden, allerdings in einem beliebigen Wertesystem. Die Reihenfolge ist dabei X, Y, Z, wobei die neative Z-Achse in die Bildschirmebene zeigt, die positive X-Achse nach rechts und die positive Y-Achse nach oben. Auf den Disketten befinden sich einige Beispiel-Files mit der Endung .inp. Sie können zur weiteren Erklärung und zum besseren Verständnis dieser Anleitung diese Files mit einer Textverarbeitung oder mit dem Editor ED einlesen und ansehen. In der deutschen Anleitung wurde die nun folgende Erklärung der Syntax dieser "Compilersprache" in der Reihenfolge der einzelnen Optionen etwas abgeändert. In der englischen Orginalausgabe erfolgt die Erklärung der einzelnen zum Befehl gehörigen Optionen in alphabetischer Reihenfolge, was bei manchen umfangreichen und mächtigen Kommandos oft sehr verwirrend ist und die Syntaxbaumstruktur nicht leicht erkennen läßt. In dieser Anleitung wurde nun ein Weg ähnlich dem AMIGA-DOS Handbuch mit folgender allgemeiner Struktur gewählt: ----------------------------------------------------------------------- BEFEHL - `DEUTSCH` ----------------------------------------------------------------------- Funktion: Kurzerklärung der Funktion Syntax : BEFEHL :== [MSG] [MACROS] [PARAMETER] [TEXTUREN] [LICHTER] [ATTRIBUTE] [OBJEKTE] MSG :== {bef*ehl TEXT} TEXT :== "text in anführungsstrichen" Erläuterung: Beispiel: ---------------------------------------------------------------------- Jeder Bestandteil eines Input-Files wird nun in der obigen Art und Weise erklärt und mit Beispielen erläutert. Die Einzelstücke der Syntax sind nun folgende: LHS :== RHS Die linke Seite ergänzt sich durch die rechte. BEFEHL Der Grundbefehl der ergänzenden Syntax (bitte nicht so eingeben). `DEUTSCH` Neben den Befehlen oder Optionen, die wegen der Syntaxerkennung in englisch bleiben müssen, steht in Anführungsstrichen die deutsche Erklärung, falls dies erforderlich ist. Manchmal wurde keine korrekte Übersetzung gefunden, was dann mit `-` angezeigt wird. Die englisch sprechenden Länder tun sich auch etwas leichter als wir mit ihren "Wortneuschöpfungen". GROSSCHRIFT Begriff nicht so eingeben. Wird weiter erklärt. klein*schrift Genauso geben Sie den Begriff bis zum Stern ein. Alles nach dem Stern ist möglich, wird jedoch vom Compiler ignoriert. [ ] Alle optionalen Ergänzungen stehen in eckigen Klammern. { } Wiederholbare Befehle oder Optionen stehen in geschweiften Klammern. | Bei einem senkrechten Strich haben Sie die Wahl zwischen den angegebenen Möglichkeiten (OR). POSTEN1 POSTEN2 Die zwei einzelnen Posten müssen in der richtigen Reihenfolge hintereinander stehen. Erläuterung: Nun noch einiges zur Erklärung der obigen Struktur: Übergeornet über dem ganzen Syntaxbaum steht also der BEFEHL, welcher jedoch durch die optionalen Ergänzungen MSG, MACROS, PARAMETER, TEXTUREN, LICHTER, ATTRIBUTE und OBJEKTE in dieser Reihenfolge vervollständigt werden kann. Die MSG selbst besteht wiederum aus dem bef*ehl selbst, der nun in dieser Form (optional nur bis zum `*`, also `bef`) eingegeben werden kann, gefolgt von einem vielleicht erklärenden "Text in Anführungsstrichen". Dieser Text wird dann beim Durchlaufen des Compilers ausgegeben. Man hat somit eine gute Möglichkeit den Compiler zu überwachen. Die restlichen Begriffe, wie z.B. MACROS werden im folgenden in alphabetischer Reihenfolge erklärt. Beachten Sie bitte noch die folgende Liste der vom Compiler ignorierten Worte. Mit Hilfe dieser Worte können Sie Ihre Befehle in englisch in verständliche Sätze einbinden. Somit schaffen Sie sich mehr Überblick über die Syntax und verstehen vielleicht bei einem späteren Durchsehen Ihrer selbsterstellten .INP Files diese besser. Der Compiler pickt sich dabei nur die für ihn wichtigen Worte heraus und tut seine Arbeit, ohne deshalb mehr Speicher oder Rechenzeit zu benötigen. Beachten Sie hierfür die Beispiel .INP Files. ----------------------------------------------------------------------- /* */ ----------------------------------------------------------------------- Funktion: Kommentare und Liste der von Compiler ignorierten Worte Syntax: /* */:== /* kommentar */ Erläuterung: Sie können an beliebiger Stelle im Text einen ergänzenden Kommentar einfügen, wenn Sie diesen mit `/*` beginnen und mit `*/` beenden. Dieser Kommentar wird jedoch im Gegensatz zu "text in anführungsstrichen" nicht später ausgegeben, sondern dient Ihnen nur als Erklärung in den ASCII-Files. Beispiel: /* dies ist ein Kommentar */ /* dies ist ein Kommentar der sich über zwei Zeilen erstreckt */ ----------------------------------------------------------------------- NOISE-WORDS - `IGNORIERTE WORTE` ----------------------------------------------------------------------- Funktion: Liste der vom Compiler ignorierten Worte Syntax: a along an and as at be by define do equals from he i in is it make my of our set she to the that this then up upto use uses using we would will with you Erläuterung: Es werden all diese Worte vom Compiler ignoriert einschließlich aller Punkt-Strichoperationen. Die vier folgenden Beispiele bewirken somit das gleiche Beispiel: scale 4 5 6 define scale of 4, 5 and 6 use scale = 4 5 6 The scalc of this will be 4 and 5 and 6 ----------------------------------------------------------------------- AMBIENT - `UMGEBUNGSLICHT` ----------------------------------------------------------------------- Funktion: Setzen des überlagernden Umgebungslicht-Faktors Syntax: AMBIENT :== amb*ient [prop*ortional] [fact*or] NUM NUM :== fließkomma-zahl Erläuterung: Unter dem Befehl ATTRIBUTES wird beschrieben, daß jedes Objekt in der Scene einen Parameter besitzt, der darüber Auskunft gibt, wie hell dieses Objekt erscheint, wenn kein Licht auf dieses fällt. So kann man geziehlt einzelne Objekte im Schatten heller erscheinen lassen, als andere. Als Alternative dazu gibt es nun diesen "amb"-Befehl mit einer Flieskomma-Zahl von 0 bis 1, der die Umgebungsfarbe der Objekte in der Scene im Schatten als ein Bruchstück der Helligkeit erscheinen läßt, mit der das Objekt im diffusen Licht erscheinen würde. Wenn dieses "amb"-Kommando verwendet wird, werden die RGB-Werte (Rot-Grün-Blau) des amb*ient-Kommandos im ATTRIBUTES-Befehl ignoriert. Dort müssen Sie aber dennoch definiert werden. Ein vorstellbarer Anfangswert für die "fließkomma-zahl" wäre zwischen 0.1 und 0.2 (Fließkomma im englischen bitte immer mit ".", also NICHT 0,2 !!!) ----------------------------------------------------------------------- ANTIALIAS - `-` ----------------------------------------------------------------------- Funktion: Setzen der Antialiasing Parameter (z.B. Vermeiden von "Treppenstufen-Diagonalen" Syntax: ANTIALIAS :== ant*ialias [CT] NUM [CT] NUM CT :== cou*nt | thr*eshold NUM :== fließkomma-zahl Erläuterung: Im Normalfall berechnet der Ray Tracer den Gang eines Lichtstrahles durch die gesamte Scene und damit zu jedem einzelnen Pixel im Bild (d.h. bei einer Auflösung von 320x400 Punkten sind dies 128000 Lichtstrahlen). Recht häufig kommt es bei dem digitalen Ablauf dieses Prozesses zu unliebsamen Nebeneffekten, wenn nur ein Lichtstrahl pro Pixel zur Berechnung herangezogen wird, wie z.B. bei der Wiedergabe von diagonalen Linien in Form einer Folge von abgehackten Treppenstufen (auch hierfür gibt es im englischen wieder ein neues Wort: "dreaded jaggies"). Diese Effekte werden im englischen mit "ALIASING DEFEKTS" bezeichnet (in Deutschland gibt es diese Defekte anscheinend nicht!!! - denn es gibt ja kein Wort dafür). Es gibt aber noch eine Menge anderer solcher ALIASING Defekte neben diesen "jaggies". Ein weiterer solcher "Fehler" sind z.B. die rasiermesserscharfen Schatten in von Computer berechneten Bildern , die es in dieser Form in der Realität gar nicht gibt. Es sind inzwischen zahlreiche Techniken erfunden worden, die nun alle unter dem Begriff "ANTIALISING" zusammengefaßt wurden. Eine Erfindung war nun, nicht nur einen einzigen Strahl zur Berechnung heranzuziehen, sondern ein Bündel von Strahlen. Der unliebsame Nebeneffekt ist jedoch, daß der Computer nun nicht mehr nur einen Strahl zu berechnen hat, sondern eben dieses "Bündel", was natürlich Rechenzeit kostet. Der COUNT (Zähl) Parameter bestimmt nun, mit wievielen Strahlen jeder Pixel im Bild gezeichnet werden soll - je mehr, um so besser, aber um so mehr Rechenzeit wird auch benötigt (Lassen Sie sich Ihr Traumbild berechnen, Während Sie in den Urlaub fahren). Ein guter Anfangswert ist 4. Es wird damit ein Bündel von Lichtstrahlen (in diesem Fall 4) auf eine Art Konus zum Pixel geschickt und dort werden diese dann horizontal und vertikal verteilt. Deshalb wird von diesem Ray Tracer auch behauptet, er habe die verteilte Lichtspur Berechnung implementiert (in englisch: Distributed Ray Tracing). Der THRESHOLD (Schwellwert, Ansprechwert) Parameter stellt die Möglichkeit für eine ziemlich komplizierte Berechnung namens statistisch optimierte verteilte Lichtspur Berechnung (Statistically Optimized Distributed Ray Tracing) dar. Hierbei werden die Helligkeiten des Bündels von Lichtstrahlen, die am Pixel verteilt werden, vom Programm berechnet. In unserem Beispiel haben wir vier Lichtstrahlen in dem Bündel. Das Programm berechnet nun die statistische Abweichung (Varianz) der vier resultierenden Helligkeiten. Ist die Abweichung gering, behält dieser Teil des Bildes vorteilhafter Weise seinen glatten, exakten Wert. Auf diese Art und Weise wird in guter Näherung die ideale Helligkeit dieses Pixels berechnet. Nun nehmen wir aber mal an, wir hätten einen dieser Pixel, die an der Ecke einer diagonalen "Treppenstufe" liegen. Dann werden nämlich die einen Strahlen auf die eine Seite der Ecke verteilt, die anderen auf die andere Seite. Die daraus resultierende Abweichungen der Helligkeit wird jetzt groß sein. Das Programm erkennt dies, und wenn dann noch diese Abweichung den vorgegebenen Schwellwert (s.o.) überschritten hat, wird eine weitere Gruppe von (in unserem Fall 4) Lichtstrahlen zum Pixel geschickt und dort verteilt. Dann wird die Abweichung dieser jetzt acht Strahlen berechnet und der gesamte Prozess wiederholt, bis sich die erforderichen glatten, exakten Werte herauskristallisieren (oder eine willkürliche Anzahl von Strahlen wurde ausgeschickt, ohne jedoch eine Verbesserung seit dem letzten Wert erreicht zu haben). Wird der Schwellwert auf 1.0 oder höher gesetzt (thr 1.0), werden außer der im COUNT-Wert festgelegten Anzahl keine zusätzlichen Strahlen erzeugt. Sehr gute Ergebnisse erreicht man mit THRESHOLD-Werten zwischen .0001 und .1. ----------------------------------------------------------------------- ATTRIBUTES - `ATTRIBUTE` ----------------------------------------------------------------------- Funktion: Definition der von den Objekten verwendeten Attribute Syntax: ATTRIBUTES :== att*ributes {TEXT | ATTRIBUTE | FRACT | INSERT } TEXT :== "text in anführungsstrichen" ATTRIBUTE :== attrib*ute ATTNAME [TFMI] NUM [TFMI] NUM [TFMI] NUM [TFMI] NUM [tra*nsparency] POINT [amb*ient] POINT [dif*fuse] COLOR ATTNAME :== alphanumerischer name TFMI :== tex*ture | fuz*ziness | mir*ror | ind*ex NUM :== fließkomma-zahl POINT :== [poi*nt] NUM NUM NUM NUM :== fließkomma-zahl COLOR :== [col*or] [RGB] NUM [RGB] NUM [RGB] NUM RGB :== red | gre*en | blu*e NUM :== fließkomma-zahl FRACT :== fra*ctal [rec*ursion] NUM [sca*le] POINT [fin*alatt] ATTNAME NUM :== fließkomma-zahl POINT :== [poi*nt] NUM NUM NUM NUM :== fließkomma-zahl ATTNAME :== alphanumerischer name INSERT :== alphanumerischer macro-name Erläuterung: Ein ATTRIBUTE ist eine Definition, die von den in der Scene dargestellten Objekten benötigt wird. Dabei wird jedem Attribut ein von Ihnen selbst gewählter Name gegeben. Eine solche Definition könnte so aussehen: Beilspiel: attributes: attribute ziegel use a texture of 5, fuzzines = .7, mirror = 0, index is 1.2, transparency 0 0 0, set ambient to 0 0 0, diffuse is .9 .6 .5 Erläuterung: tex*ture: `Textur` In Anhang B sind alle zur Verfügung stehenden Texturen aufgeführt (texture 5 ist z.B. Ziegelstein). fuz*ziness: `Unschärfe` Dies ist ein Pseudo-Textur-Faktor, der mit Werten zwischen 0 (=scharf) und 1 (=unscharf) die Oberfläche der Objekte in einer beliebig wählbaren Unschärfe erscheinen läßt. Er kann auf verschiedene Art und Weise eingesetzt werden: um die weiche Oberfläche eines Tennisballes zu simulieren; um nicht exakt reflektierende Spiegel oder geschliffenes, mattes Glas naturgetreu erscheinen zu lassen und vieles mehr. mir*ror: `Spiegel` Hiermit können Sie die ordentliche Reflexion und reflektierende Objekte mit Werten zwischen 0 (keine Reflexion) und 1 (100% Reflexion) bestimmen. ind*ex: `Brechungsindex` Damit bestimmen Sie den Brechungsindex der Objekte, also z.B. von Glas oder Wasser, was natürlich nur für transparente Objekte gilt, deren tra*nsparency-Wert nicht 0 ist. Geben Sie einfach den Ihnen bekannten Brechungsindex des Materials ein (z.B. in Physikbüchern nachzuschlagen). tra*nsparency: `Transparenz` ist die Durchlässigkeit des Objektes für die einzelnen Farben rot, grün und blau mit Werten zwischen 0 (opak) und 1 (vollkommen transparent). Die Durchlässigkeit für Mischfarben wird durch verschiedene rot-grün-blau Werte bestimmt. amb*ient: `Umgebungslicht` Im Gegensatz zum weiter oben beschriebenen eigenständigen AMBIENT-Befehl, der ja für die gesamte Scene den Faktor für sich im Schatten befindliche Objekte beschreibt, wird hier nun das einzelne Objekt angesprochen. D.h. Sie können hier ganz spezifisch die Helligkeit der einzelnen rot-grün-blau Werte eingeben, in denen das Objekt im Schatten erscheinen soll. Dabei sind Werte zwischen 0 (dunkel) und 1 (hell) möglich, wobei zu helle Farben den Gegenstand "ausfressen" und ja auch nicht sinnvoll sind. dif*fuse: `Diffusion` ist eine Art der Reflexion eines Gegenstandes und uns eher als die Farbe des Gegenstandes bekannt, was jedoch nur im neutralen weißen Licht stimmt. Glass z.B. hat keinerlei diffuse Reflexion, während Kreide eine sehr hohe besitzt (fast 1). Mit diesem Diffusionsfaktor bestimmen Sie, wie stark ein Objekt in seiner Farbe von der Beleuchtung beeinflußt wird. Ein hoher rot-, mittlerer grün- und niedriger blau-Wert besagt dann z.B., daß dieses entsprechende Objekt rotes Licht sehr stark, grünes mittel und blaues nur schwach aufnimmt, was ihn im neutralen weißen Licht rotbraun erscheinen läßt. Jedoch erscheint dieser gleiche Körper im rein roten Licht sehr viel heller, als in einem rein grünen Licht oder gar im ausschließlich blauen Licht, wo er fast schwarz ist. Es sind Werte zwischen 0 und 1 für die einzelnen Farbkomponenten zugelassen. Mit den oben genannten Einstellmöglichkeiten können Sie auch vollkommen irrationale Objekte erstellen. So können Sie sich auch mal einen Ball mit 100% Transparenz und gleichzeitig 100% Refexion ansehen, wie er in der Natur wohl nie vorkommen wird! fra*ctal: `-` Neben dem FRACTAL-Befehl, der weiter unten beschrieben ist, gibt es noch diese fra*ctal-Textur. Jedes hier definierte Fraktal erzeugt eine neue Textur, auf die andere Attribute unter Aufrufen der entsprechenden Nummer zurückgreifen können. Die Durchnummerierung der Fractal-Texturen beginnt bei Nr.60. Hier nun ein Beispiel, um einen Berg zu definieren: Beispiel: attributes: attribute fels use a texture of 20, fuz = 1.2, mirror = 0, index is 1.2, trans = 0 0 0, amb = 0 0 0, dif .5 .3 0 fractal /* Pseudo-Textur Nr.60 */ recursion 5 scale .08 1.3 .08 finalatt fels attribute berg use a texture of 60 fuz 0 mir 0 ind 0 tra 0 0 0 amb 0 0 0 dif 0 0 0 Damit ist "berg" zu einem "attribute" geworden, der aus "fractals" gebildet wurde und diese wiederum besitzen die Textur "fels". Für eine nähere Erklärung der "fractals" und dessen Optionen sehen Sie bitte unter dem FRACTAL-Befehl weiter unten nach! ----------------------------------------------------------------------- BACKGROUND - `HINTERGRUND` ----------------------------------------------------------------------- Funktion: Setzen der Hintergrundfarbe Syntax: BACKGROUND :== bac*kground COLOR COLOR :== [col*or] [RGB] NUM [RGB] NUM [RGB] NUM RGB :== red | gre*en | blu*e NUM :== fließkomma-zahl Erläuterung: Ein einfacher Farbwert, der immer dann angezeigt wird, wenn an einer bestimmten Stelle im Bild kein Objekt dargestellt ist. ----------------------------------------------------------------------- BLEND - `VERLAUFENLASSEN` ----------------------------------------------------------------------- Funktion: Definiert eine Textur mit Farbverläufen Syntax: BLEND :== ble*nd COLOR-SR COLOR-SR :== [col*or] [RGB] NUM [RGB] NUM [RGB] NUM [SR] NUM [SR] NUM RGB :== red | gre*en | blu*e NUM :== fließkomma-zahl SR :== sta*rt | ran*ge Erläuterung: Normalerweise hat ein Objekt eine einheitliche, durchgehend gleiche Farbe auf der Oberfläche. Mit diesem BLEND-Kommando können Sie nun eine Verlauffunktion definieren, die Sie an jedem Objekt anwenden können. Dabei variiert die Farbe des Objektes mit der Höhe, also mit der Zunahme der Y-Koordinate. So könnte eine Kugel am Südpol blau und am Nordpol gelb sein und dazwischen weich die Farben ineiander übergehen lassen. So können Sie bis zu 10 Farbverläufe pro Scene definieren. Die drei Farbwerte bestimmen dabei die Zielfarbe, in die die Grundfarbe des Objektes mit wachsender Y-Koordinate verlaufen soll. Die Grundfarbe des Gegenstandes wird durch den oben besprochenen dif*fuse Wert im ATTRIBUTES-Befehl eingestellt. Der sta*rt-Wert legt die niedrige Y-Koordinate fest, ab der der Farbverlauf beginnt; Pixels unterhalb dieses Y-Wertes behalten die Orginal Objektfarbe der dif*use Einstellung. ran*ge `Bereich` gibt die vertikale Ausdehnung in Einheiten an in der der gesamte Farbverlauf stattfindet. Ab dem addierten sta*rt+ran*ge Wert existiert dann im Objekt nur noch die zuvor im BLEND-Befehl festgelegte Zielfarbe. Stellen Sie sich mal eine Kugel mit Radius 50 (Durchmesser 100) vor und mit dem Mittelpunkt im Ursprung. Wenn der sta*rt-Wert auf -33 und der ran*ge-Wert auf 66 gesetzt wird, erhalten Sie eine Kugel, die im unteren Drittel die Grundfarbe des dif*fuse-Wertes, im mittleren Drittel den Farbverlauf kontinuierlich von Grundfarbe bis Zielfarbe und im oberen Drittel alleine die Zielfarbe des BLEND-Befehles enthält. ----------------------------------------------------------------------- CHECK - `SCHACHBRETT` ----------------------------------------------------------------------- Funktion: Definition einer 3D-Schachbrett Textur Syntax: CHECK :== che*ck COLOR [wid*th] [siz*e] POINT COLOR :== [col*or] [RGB] NUM [RGB] NUM [RGB] NUM RGB :== red | gre*en | blu*e NUM :== fließkomma-zahl POINT :== [poi*nt] NUM NUM NUM NUM :== fließkomma-zahl Erläuterung: Sie können bis zu 10 Schachbrett-Texturen pro Scene definieren. In dieser Texturfunktion werden die Farben der Oberfläche eines Objektes bestimmt , wobei entweder ein eindimensionaler Layer, ein zweidimensionales Gitter oder ein dreidimensionales Blockmodell angewendet wird. Sobald die Farbe der Punkte einer Oberfläche bestimmt wurde, kann diese Funktion dazu verwendet werden, um festzulegen, ob die Farbe eines ausgewählten Punktes diejenige der in dif*fuse ausgewählten, oder eine andere in dieser Funktion mit den COLOR-Parametern erzeugten sein soll. Um nun bestimmen zu können, ob ein Punkt innerhalb oder außerhalb einer dieser Farbregionen liegt, werden die X- Y- und Z- Werte der Mustergröße überprüft. Dabei bestimmt der X-Wert die Breite der aufeinanderfolgenden Layer von links nach rechts, der Y-Wert die Höhe der Layer von oben nach unten und der Z-Wert die Tiefe von vorn nach hinten. Beachten Sie dabei, daß einer oder mehrere dieser Werte auf 0 gesetzt werden kann. Dies wird jegliche Variierung des Musters in der dazugehörigen Dimension unterbinden. Wenn z.B. der X- und der Z-Wert auf 10 und der Y-Wert auf 0 gesetzt wird, dann werden vertikale quadratische Spalten mit wechselnder Farbe erscheinen. Wird jedoch nur Y ungleich 0 gesetzt, sieht man horizontale Streifen abwechselnder Farbe. Setzt man alle drei ungleich 0 wird ein räumliches 3D-Block-Muster erscheinen. Dabei müssen die X-, Y- und Z-Werte nicht gleich sein. So können z.B. lange flache Blocks erzeugt werden. ----------------------------------------------------------------------- DIFFUSE - `DIFFUSION` ----------------------------------------------------------------------- Funktion: Setzen der allgemeinen diffusen Reflexion der Scene. Syntax: DIFFUSE :== dif*fuse [lig*hting] [SDO] NUM [SDO] NUM [SDO] NUM SDO :== sam*ples | div*ide | ove*r NUM :== fließkomma-zahl Erläuterung: Dieses Kommando wurde geschaffen, um realistisch darstellen zu können, wie Licht von einen Gegenstand in der Scene auf den andern reflektiert wird. Traditioneller Weise wird in von Computer berechneten Beleuchtungsmodellen der von einer Lichtquelle angestrahlten Oberfläche eines Objektes eine den Materialeigenschaften, der Farbe und Intensität des Lichtes entsprechende Farbe gegeben. Das Objekt oder diejenigen Teile eines Gegenstandes, die sich nicht direkt im Lichtkegel befinden, werden dementsprechend schwarz wiedergegeben. Das sieht normalerweise recht künstlich aus. Deshalb wird den Schattenbereichen ein konstantes, gedämpftes Licht zugewiesen. (Wie Sie sich vielleicht erinnern können, stellt dieses Programm Ihnen mit dem amb*ient-Befehl und dem ATTRIBUTES-Kommando Befehle zur Verfügung, mit denen Sie dies ebenfalls beheben können). In der Realität werden die Schatten jedoch mit dem Licht ausgeleuchtet, das von Wänden usw. abprallt bzw. reflektiert wird. Um dieses diffuse von Objekt zu Objekt reflektierte Licht bestimmen zu können, haben wir dieses DIFFUSE-Kommando eingeführt. Schade nur, daß mit diesem Kommando wieder einmal trotz seiner Perfektion die Ausführungsgeschwindigkeit leidet. Denn es müssen erst eine Menge Daten über die Scene gesammelt und analysiert werden, um zu bestimmen, wie die Schattenbereiche des Bildes beeinflußt werden. Dieses Programm tut nun folgendes: Von jedem einzelnen Bildpunkt einer Oberfläche werden Lichtstrahlen in zufälliger Richtung in die gesamte Scene geschickt, um erkennen zu können, ob eventuell nahestehende Objekte als Reflektoren wirken könnten. sam*ples `Abtastungen` gibt an, wieviele solcher Lichtstrahlen von der Oberfläche für eine Abtastung ausgesendet werden sollen; Werte ab 10 sind zwar möglich, um jedoch wirklich natürliche von-Objekt-zu-Objekt Reflexionen darstellen zu können, sind über 100 Abtastungen notwendig. div*ide `dividiere` (Zähler) ove*r `durch` (Nenner) div*ide und ove*r ergeben sich eigentlich aus der rekursiven Natur des Ray Tracing Prozesses: Stellen Sie sich einmal vor, ein zu berechnender Strahl einer bestimmten Oberfläche streift nun eine benachbarte Oberfläche. Nun - von dieser Oberfläche geht natürlich erneut eine Anzahl von Abtastungen aus, um wiederum dessen Oberflächenfarbe zu bestimmen usw.. Deshalb würde die Anzahl der zu berechnenden Strahlen exponentiell ansteigen. Um nun dieses rekursive Wachstum zu vermeiden, wird zum einen die Anzahl der zu berechnenden Strahlen pro Rekursions-Ebene mit sam*ples begrenzt, welches sich wiederum von Ebene zu Ebene verändert, abhängig von den div*ide und ove*r-Werten. Wird z.B. div*ide, also der Zähler auf 1 und ove*r (Nenner) auf 2 gestellt, heißt dies, daß sich die Anzahl der Abtastungen pro Rekursionsebene um die Hälfte verringert. Jedoch auch dies ist eine noch zu kleine Verminderung, besser sind Werte mit div 1 ove 3 (also 1/3) oder div 1 ove 4 (also 1/4), ohne dabei im Bild erkennbare Einbußen zu erleiden. Der Zähler kann auch auf 0 gestellt werden, was eine Rekursion sofort unterbindet. ----------------------------------------------------------------------- FOCUS - `SCHÄRFE` ----------------------------------------------------------------------- Funktion: Einstellen der Blendenöffnung und der Schärfe zur Festlegung der Schärfentiefe Syntax: FOCUS :== foc*us [AD] NUM [AD] NUM AD :== ape*rture | dis*tance NUM :== fließkomma-zahl Erläuterung: Dieses Kommando kann optional eingegeben werden; wird es unterlassen, dann wird in der Scene einfach alles Scharf gestellt (Lochkamera-Effekt). Verwenden Sie jedoch dieses Kommando, um geziehlt in der Scene mit der Schärfentiefe zu arbeiten (natürlich gibt es auch hier wieder beträchtliche Einbußen in der Rechenzeit!). ape*rture `Blendenöffnung` Diese legt die hypothetische Öffnungsweite der Optik unserer "Kamera" fest, die wir zum Fotografieren unserer Scene verwenden. dis*tance `Entfernung` legt die Entfernung von der Kamera (oder dem Betrachter) fest, in der alle Objekte exakt scharf abgebildet werden. Die Größenverhältnisse beider Werte sind natürlich von dem in Ihrer Scene verwendeten Koordinatensystem abhängig. Wir wollen Ihnen hier aber dennoch ein Beispiel einer vorstellbaren Einstellung geben. Nehmen wir an, eine Entfernungseinheit beträgt 1 inch. Sollten Sie nun die Schärfe auf 100 inches eingestellt haben, dann wären vorstellbare Einstellungen für die Blendenöffnung 0.5 bis 2.0, also: Beispiel: focus aperture 0.6 distance 100 Um im unscharfen Vorder- und Hintergrund weiche Übergänge zu erhalten, sollten Sie die ANTIALIASing Werte auf 20 bis 30 Strahlen pro pixel einstellen (count 30). Den thr*eshold-Wert können Sie bei 1 belassen (thr 1). ----------------------------------------------------------------------- FRACT - `-` ----------------------------------------------------------------------- Funktion: Definieren von Parametern für `Fractal`-Oberflächen Syntax: FRACT :== fra*ctal [rec*ursion] NUM [sca*le] POINT [fin*altexture] NUM NUM :== fließkomma-zahl POINT :== [poi*nt] NUM NUM NUM NUM :== fließkomma-zahl NUM :== fließkomma-zahl Erläuterung: Diese Texturparameter können nur den weiter unten definierten FRACTAL-Objekten zur Verfügung gestellt werden. Der Ray Tracer kann bis jetzt nur einige wenige primitive Objekte darstellen. Eines dieser Objekte ist das Dreieck. Wie weiter unten beschrieben wird, kann der Ray Tracer mathematisch aus einer großen Zahl von aneinandergehängten Dreiecken Verbundobjekte konstruieren, die "stochastische Oberflächen" genannt werden (oft denkt man dabei an Fractal-Oberflächen, in Wirklichkeit jedoch ist deren mathematische Verwandschaft zu Fractals begrezt). Dieses Kommando definiert Parameter, die der Ray Tracer zur Konstruktion des Netzes von Dreieck Oberflächen benötigt. Sie können bis zu 10 solcher Oberflächen definieren. Wenn Sie die Absicht haben, eine Fractal-Oberfläche zu definieren, müssen Sie noch mindestes eine Wellen-Quelle mit dem WAVES-Kommando weiter unten definieren (der Grund dafür wird später erklärt). Die generelle Fractal-Konstruktion baut auf der rekursiven Dreiecks-Unterteilung auf und wendet umfangreiche Koordinatenverschiebungen an, wenn die vertikalen Stützen der Dreiecks-Unterteilung bestimmt werden. Sie beginnen mit einem Ursprungsdreieck, das die Gesamtgröße und die Orientierung der fertigen Oberfläche kontrolliert. Das Ursprungsdreieck wird in vier Dreiecke aufgeteilt (Halbierung der drei Seiten und Verbinden der Mittelpunkte). Die Ecken der neuen Dreiecke werden in den Raum angehoben und weiter rekursiv unterteil, bis zum angegebenen Grenzwert. rec*ursion `Rekursion` legt diesen obengenannten Grenzwert fest; je höher dieser Wert, um so feiner und detaillierter ist die spätere Oberfläche, aber um so länger braucht auch das Programm zur Berechnung (vier mal so viel mit jedem steigenden Level). Außerdem benötigt ein höherer Grenzwert bedeutend mehr adressierten Speicher, um die errechneten Dreieckswerte zwischenspeichern zu können (tausende von 512-byte Packeten z.B. bei einem Level von 7...also seien Sie vorsichtig!). sca*le poi*nt `Maßstab` Die X-, Y- und Z-Werte ermöglichen verschiedene Verzerrungen in den drei Dimensionen (X = 1.0, Z = 1.0, Y = 3.0 erzeugt ein Relief, das dreimal so hoch ist, wie seine horizontalen Abmessungen). Ein Maßstabswert von 0 bewirkt, daß sich die unterteilten Dreiecke nicht in dieser Richtung fortpflanzen. fin*altexture `Abschlußtextur` Als Abschlußtextur kann eine Texturnummer für jedes einzelne Unterdreieck angegeben werden. Beachten Sie dabei die Beschreibung der Texturfunktion für Objekte weiter unten). Grundsätzlich können Sie so dem Fractal eine einheitliche Textur geben: eine Farbe, ein Schachbrettmuster oder ähnliches. Wie wir vorhin vorgeschlagen haben, sollten Sie vorher einige Wellenquellen definiert haben, um schön rauhe Oberflächen zu erhalten. Ein guter Anfang wäre, fünf oder sechs Wellenquellen zu definieren und deren Ursprünge in der Scene verteilt zu setzten. Wenn Sie Wellenlängen und die Amplituden unterschiedlich setzen, wird die Oberfläche mehr zerklüftet. Im allgemeinen sollte die Dämpfung gering sein (Werte um die 1.0). Wie die Wellen die vertikalen Stützstellen der Unterdreiecke beeinflussen wird weiter unten beschrieben. Diese Stützen werden also nicht von Zufallszahlen erzeugt, sondern können durch Variation der Wellenparameter geziehlt gesteuert. Experimentieren Sie ruhig etwas. ----------------------------------------------------------------------- FRACTAL - `FRACTAL-OBJEKT` ----------------------------------------------------------------------- Funktion: Ähnlich des oben beschriebenen FRACT-Kommandos Syntax: FRACTAL :== fra*ctal ATTNAME PARS ATTNAME :== alphanumerischer-name PARS :== SIEHE PARS-KOMMANDO Erläuterung: Während im FRACT-KOMMANDO oben die X-, Y- und Z-Werte der Stützstellen der Unterdreiecke relativ zur Basis des Dreieckes bestimmt werden, sind bei einem FRACTAL-Objekt alle drei X-, Y- und Z-Werte die absoluten Raumpositionen eines Objektes. Für PARS-Parameter sehen Sie bitte unter dem PARS-Kommando nach. ----------------------------------------------------------------------- HAZE - `DUNST` ----------------------------------------------------------------------- Funktion: Erzeugung eines Dunstschleiers mit wachsender Entfernung Syntax: HAZE :== haz*e COLOR-D COLOR-D :== [col*or] [RGB] NUM [RGB] NUM [RGB] NUM [dis*tance] NUM RGB :== red | gre*en | blu*e NUM :== fließkomma-zahl Erläuterung: Wenn dieses Kommando unterlassen wird, bleiben alle Farben der einzelnen Pixels diejenigen, wie sie bestimmt wurden, egal wie weit das Objekt vom Betrachter entfernt ist. Verwenden Sie nun diesen haz*e-Befehl, bewirken Sie eine immer stärkere Überlagerung der Farben mit einem Dunst-Parameter, je weiter das Objekt bzw. die Landschaft von Betrachter entfernt ist. col*or `Farbe` legt die Dunstfarbe mit den drei RGB-Werten fest. dis*tance `Entfernung` Alle Objekte, die sich in einer größeren Entfernung befinden, als im dis*tance-Wert festgelegt wurde, werden vollkommen mit Dunst überlagert, bzw. sind dann völlig unsichtbar. Objekte, die sich vor dem dis*tance-Wert befinden, werden kontinuierlich von ihrer wahren Ursprungsfarbe im Vordergrund nach hinten mit Dunst mit linear steigender Tendenz als Funktion der Entfernung überlagert. ----------------------------------------------------------------------- IFF - `IFF-BILDER` ----------------------------------------------------------------------- Funktion: Textur mit einem IFF/ILBM-Bild Syntax: IFF :== iff [siz*e] NUM NUM [edge] NUM NUM [fil*ename] QUOTE NUM :== fließkomma-zahl QUOTE :== "text in anführungsstrichen" Erläuterung: Mit diesem Kommando können Sie ein IFF-Bild in den Ray Tracer einlesen, um dieses als Textur für beliebige Objekte verwenden zu können. Beachten Sie aber, daß nur ein einziges Bild als Textur verwendet werden kann (wegen des begrenzten Speicherplatzes). Dieses Bild wird als Textur Nr.6 (siehe Anhang B) eingelesen. BRICK.INP ist ein Beispiel für die Verwendung einer solchen Textur. siz*e `Größe` wird dazu verwendet, um die Abbildungsgröße eines Bildes zu definieren. Ein typisches 320x400 Pixel enthaltendes Bild wird in der "natürlichen" Scene mit den von siz*e festgelegten Koordinaten abgebildet. edge `Ecke` legt fest, wo sich die Ecke des Bildes befindet. Beispiel: iff size 60 60 edge -30 -30 filename "brick.ilbm" Dieses Beispiel definiert eine Textur mit Hilfe des Bildes "brick.ilbm" `Ziegel`, wobei das gesamte Bild 60x60 Einheiten groß ist und mit der Ecke bei -30 -30 beginnen wird. Dies bedeutet, daß das Bild bei 0 0 zentriert wird und sich alle 60 Einheiten in X- und Y- oder Z-Richtung wiederholt. ----------------------------------------------------------------------- INDEX - `BRECHUNGSINDEX` ----------------------------------------------------------------------- Funktion: Optionale Bestimmung des globalen Brechungsindex der Luft Syntax: INDEX :== ind*ex [ref*raction] NUM NUM :== fließkomma-zahl Erläuterung: Mit diesem globalen, optionalen Kommando können Sie den Brechungsindex der umgebenden "Luft" einstellen oder so eine Art anderen "Raum" zwischen und außerhalb den Objekten erzeugen (z.B. mit Luft gefüllte Glaskugeln im Wasser aus der Sicht eines Tauchers). ----------------------------------------------------------------------- INSERT - `EINSETZEN` ----------------------------------------------------------------------- Funktion: Einsetzen eines Makros an dieser Stelle Syntax: INSERT :== MACRO [PARS] MACRO :== alphanumerischer macroname PARS :== SIEHE PARS-KOMMANDO Erläuterung: Wenn dieses Makro als ein "OBJECT" eingesetzt wird, muß es mit dem PARS-Kommando ergänzt werden, sonst nicht. Für Details des PARS-Kommandos sehen Sie bitte unter demselben nach. Wenn Sie ein Makro für ein Objekt aufrufen, dürfen darin nur folgende Parameter definiert sein: SCALE, ROTX, ROTY, ROTZ, und TRANSLATE (RADIUS nur, wenn es erforderlich ist). Wenn Sie z.B. ein Makro mit dem Namen gebäude aufrufen wollen schreiben Sie: Beispiel: gebäude scale 1 2 3 roty 27.4 translate 15 20 30 ----------------------------------------------------------------------- LIGHTS - `LICHTQUELLE` ----------------------------------------------------------------------- Funktion: Definieren von Lichtquellen Syntax: LIGHTS :== lig*hts { MSG | DIRECTIONAL | SPHERICAL | INSERT}* MSG :== "text in anfürungsstrichen" DIREKTIONAL :== dir*ectional COLOR POINT COLOR :== [col*or] [RGB] NUM [RGB] NUM [RGB] NUM RGB :== red | gre*en | blu*e NUM :== fließkomma-zahl POINT :== [poi*nt] NUM NUM NUM NUM :== fließkomma-zahl SPHERICAL :== sph*erical COLOR [cen*ter] POINT [DR] NUM [DR] NUM COLOR :== [col*or] [RGB] NUM [RGB] NUM [RGB] NUM RGB :== red | gre*en | blu*e NUM :== fließkomma-zahl POINT :== [poi*nt] NUM NUM NUM NUM :== fließkomma-zahl DR :== [dis*tance] | [rad*ius] NUM :== fließkomma-zahl INSERT :== SIEHE INSERT-KOMMANDO Erläuterung: Ihnen stehen zwei verschiedene Lichtquellen zur Verfügung: gerichtetes, gleichmäßiges Licht und punktförmige Lichquellen. dir*ectional `gerichtet` Dies ist Licht mit parallelen Strahlen und konstanter Leuchtkraft, wie wir es eigentlich nur von der Sonne her kennen und was, rein physikalisch gesehen, auch nur hier auf der Erde näherungsweise richtig ist. Holen Sie sich Ihre Sonne mit diesem Programm ins Zimmer! Die ersten drei Zahlen legen die Farben und die Intensität der Lichtquelle fest. 1 1 1 wäre helles, weißes Licht, 0.5 0 0.5 wäre schwaches magentafarbenes Licht. Die zweiten drei Zahlen geben die Richtung an, aus der das Licht scheint. 1 0 0 bedeutet z.B., daß das Licht genau aus der X-Richtung scheint, und zwar aus der positiven in die negative Richtung. Sie können bis zu 10 Lichtquellen aus verschiedenen Richtungen pro Scene definieren. Passen Sie aber auf: zu viele Lichtquellen bremmmmmmmsen die Berechnung beträchtlich. Zwei Lichtquellen ist realistisch. Außerdem verwenden selbst Profifotografen selten mehr als drei Lichtquellen und wenn, dann nur, weil sie keine gerichteten Lichtquellen mit konstanter Lichtstärke haben, wie sie hier möglich sind, um einen großen Raum auszuleuchten. sph*erical `punktförmig` Eine punktförmige Lichtquelle ist im Idealfall eine Lichtquelle, wie wir Sie aus dem täglichen Leben kennen. Das Licht breitet sich dabei von der Lichtquelle ausgehend in allen Richtungen gleichmäßig aus, wobei die Lichtintensität mit wachsender Entfernung im Verhältnis des indirekten Quadrates zur Distanz zur Quelle abnimmt. Mit den ersten drei Werten legen Sie wie bei der gerichteten Lichtquelle die Farbe und Ausgangsintensität fest. Die zweiten drei Zahlen geben den Standpunkt der Lichtquelle im Raum an, wobei es egal ist, ob dieser sich innerhalb oder außerhalb der sichtbaren Scene befindet. Beachten Sie jedoch: falls sich die Lichtquelle innerhalb des sichtbaren Bereichse befindet, wird sie nicht als Objekt als solches dargestellt. Wollen Sie z.B. eine leuchtende Glühbirne darstellen, dann müssen Sie an die gewünschte Stelle im Raum die Lichtquelle und zugleich eine transparente Kugel mit gleichem Radius setzen. dis*tance `Entfernung` bezieht sich auf das Gesetz des umgekehrten Quadrates des Lichtes, das beschreibt, wie die Lichtintensität in einem Raum mit wachsender Entfernung von der Lichtquelle abnimmt. Um den dis*tance-Wert am leichtesten zu erklären, stellen Sie sich folgendes vor: Sagen wir mal, wir haben eine Lichtquelle mit voller Intensität und weißem Licht (RGB-Werte 1 1 1),die auf einen Tisch scheint. Wenn der Tisch sagen wir einmal 37 Einheiten unterhalb der Lichtquelle steht, dann sollten Sie den dis*tance-Wert ebenfalls auf 37 stellen, um den Tisch mit voller Helligkeit zu beleuchten. Objekte, die sich nun näher als 37 Einheiten von der Lichtquelle entfernt befinden, werden überstrahlt dargestellt, während Objekte, die sich weiter weg von der Lichtquelle befinden, immer schwächer beleuchtet werden. rad*ius `Radius` Damit kann der Radius der Lichtquelle bestimmt werden. Ein Wert von 0.0 wäre eine "ideale" punktförmige Quelle, die auch am schnellsten berechnet werden kann. Bedenken Sie jedoch, daß es in der Natur nie ideale Punktstrahler gibt. Die nicht-Punktstrahler mit endlichem Radius werfen außerdem die berümten "Halbschatten", wozu Sie sonst mit dem ANTIALIASING-Kommando korrigieren müssten. Beispiel: lights: directional color 1 1 1 from 0 1 0 spherical color 1 1 1 center at 50 50 -75 ----------------------------------------------------------------------- LOOK - `BLICK` ----------------------------------------------------------------------- Funktion: Festlegen des Kamerastandpunktes und der -blickrichtung Syntax: LOOK :== loo*k POINT POINT POINT POINT :== [poi*nt] NUM NUM NUM NUM :== fließkomma-zahl Erläuterung: Die ersten drei Werte legen den Kamerastandpunkt fest. Die zweiten drei Zahlen geben die Blickrichtung relativ zu diesem Standpunkt an. Die Länge dieses Vektors legt fest, ob wir die Scene mit "Weitwinkel" Charakter oder mit dem Teleobjektiv betrachten. Um Ihnen zu erklären, was die unterschiedliche Länge bedeutet: An der Spitze des Blickvektors wird der Bildschirm abgebildet, als wenn er 256 Einheiten breit und 170 Einheiten hoch wäre. So steht die Anzahl der von Ihnen ausgewählten X-, Y- und Z-Punkte in direktem Zusammenhang mit der Länge des Blickvektors und bestimmt so den Blickwinkel. Die letzten drei Werte geben die Blickrichtungshöhe an. Normale Einstellungen sind 0 1 0. ----------------------------------------------------------------------- MACS - `MAKROS` ----------------------------------------------------------------------- Funktion: Definierung von Makros für den späteren Gebrauch Syntax: MACS :== mac*ros { MSG | IMPORT | MACDEF }* MSG :== mes*age "text in anführungsstrichen" IMPORT :== imp*ort FILE FILE :== "text in anführungsstrichen" MACDEF :== macro NAME { TOKEN }* done NAME NAME :== alphanumerischer name TOKEN :== beliebige definitionen NAME :== alphanumerischer name wie oben Erläuterung: Hier zeigt sich die wirkliche Kraft dieser Eingabe-Sprache. Makros können überall verwendet werden - um sie zu sehen und überall in der Syntax einzusetzen. Ein Beispiel-Makro (genannt StandardLicht) wird nun erklärt: Beispiel: macro StandardLicht directional color of 1 1 1 from .1 .1 1 directional color of 1 1 1 from 1 1 0 done StandardLicht Um dieses Makro nun einzusetzen (vergleiche mit INSERT) schreibt man: lights: StandardLicht Wenn Sie Makros bei Objekten einsetzen, können Sie Verbund-Objekte erzeugen, die anschließend behandelt werden können, als wären Sie eine Einheit. Wenn Sie z.B. ein Bauwerk definieren, schreiben Sie: Beispiel: macro bauwerk object ziegel point -1 -1 0 point -1 1 0 point 1 1 0 point 1 -1 0 point -1 -1 0 route point 0 0 -1 point 0 0 1 close 1 1 text "mein haus" black scale .15 .45 .3 roty -90 trans 1.02 .6 0 done bauwerk Dieses Objekt können Sie nun komplett manipulieren mit: bauwerk scale 40 27 30 translate -80 -27 60 ----------------------------------------------------------------------- MARB - `MARMOR` ----------------------------------------------------------------------- Funktion: Definieren einer Marmor-Textur Syntax: MARB :== mar*ble [vei*n] COLOR-XTS COLOR-XTS :== [col*or] [RGB] NUM [RGB] NUM [RGB] NUM [XTS] NUM [XTS] NUM [XTS] NUM RGB :== red | gre*en | blu*e NUM :== fließkomma-zahl XTS :== xsc*ale | tur*bulance | squ*eeze Erläuterung: Sie können bis zu 10 Marmor-Texturen pro Scene definieren. Diese Textur ist wieder von mindestens einer Wellendefinition abhängig, aus Gründen, die wir nun besprechen. Ein Marmor besteht aus einer Basissubstanz, die Intrusionen (Eindringungen von feurig, flüssigem Gestein in Absatzgestein) einer zweiten Substanz enthält. Die Basisfarbe wird von den dif*fuse Koeffizienten des Objektes bestimmt. vei*ncolor `Marmorierung` Die Farbe der Marmorierung wird durch diese drei Parameter festgelegt. Die spätere tatsächliche Farbe des Objektes ist ein Konglomerat aus beiden. Die grundsätzliche Methode der Erzeugung der Marmorierung ist der Start mit gleich aufgeteilten vertikalen Layers entlang der X-Achse. xsc*ale `Maßstab X-Richtung` bestimmt dabei den Leerraum zwischen diesen Layers. Vernünftige Werte liegen dabei zwischen 0.1 und 1. Nun werden in diesen Layers Turbulenten erzeugt, die diese in wilde Schlieren, Kringel u.a. deformieren. tur*bulence `Turbulenzen` stellt dabei die Heftigkeit dieser ein (schöne Resultate erhält man mit Werten zwischen 1.0 und 3.0). squ*eeze `Zerdrücken` Dieser Parameter bestimmt die grobe Dicke der Schlieren (dieser muß ein Integer-Wert, also nur ganzzahlig sein). Ein Wert von 1.0 beläßt die Schlieren in Ihrer Dicke, 2 bedeutet doppelt so dünn, drei viermal und vier achtmal so dünn. Außerdem legt squ*eeze fest, wie schnell die beiden Farben ineinander verlaufen. Die Turbulenz als solche wird jedoch von den definierten Wellen "gesteuert". Unglücklicher Weise ist die Steuerung der Turbulenz durch gezeihlte Auswahl der Wellen nicht vohersehbar, obwohl eine Abhängigkeit durchaus vorhanden ist, also keine Zufallszahlen mitwirken.Es können lediglich hier Richtwerte für die Wellenparameter gegeben werden. Die Wellenzentren sollten über die gesamte Scene verteilt sein. Die Wellenlängen sollten in einem großen Bereich schwanken (einige sollten die fünf- oder sechsfache Wellenlänge der anderen haben). Der Dämpfungsfaktor sollte gering sein (zwischen 0.95 und 1.0). ----------------------------------------------------------------------- MSG - `NACHRICHT` ----------------------------------------------------------------------- Funktion: Compilernachricht an den User Syntax: MSG :== {mes*sage QUOTE} QUOTE :== "text in anführungsstrichen" Erläuterung: Wenn Sie dieses Kommando verwenden wird eine Nachricht während des Compilierens an den "Programmierer" ausgegeben, sobald der Compiler an der entsprechenden Stelle angelangt ist. Die ausgabe erfolgt sowohl auf dem Bildschirm, als auch in das .dat-File. Beispiel: message "Dies ist eine Nachricht" mes "und noch eine" ----------------------------------------------------------------------- OBJ - `OBJEKT` ----------------------------------------------------------------------- Funktion: Definieren eines Translations- oder Rotationsobjektes Syntax: OBJ :== obj*ect ATTNAME PARS OBJTYP ATTNAME :== alphanumerischer name PARS :== SIEHE PARS-KOMMANDO OBJTYP :== OBJROUTE | OBJROT OBJROUTE :== route { PT [sca*le NUM] }* [clo*se BEGIN END] PT :== point NUM NUM NUM NUM :== alphanumerische-zahl NUM :== alphanumerische-zahl BEGIN :== 0 | 1 END :== 0 | 1 OBJROT :== [side*s NUM] [arc NUM] [clo*se BEGIN END] NUM :== alphanumerische-zahl BEGIN :== 0 | 1 END :== 0 | 1 Erläuterung: Hiermit können Sie sowohl Translations- als auch Rotationsobjekte definieren. Um ein Rotationsobjekt zu konstruieren, legen Sie es zuerst entlang der Y-Achse aus (verwenden Sie X als Radius) und lassen Sie das System nun die Punkte um die Y-Achse herumspinnen. Beispiel: OBJ attribute POINT 1 0 0 POINT 0 1 0 SIDES 8 erzeugt einen Konus mit 8 Seiten (je mehr Sie definieren, um so weicher wird dieser dargestellt). Nun wollen wir zwei Konuse sich überkreuzen lassen und ihre "Nasen" aneinanderhängen: Beispiel: OBJ attribute POINT 1 0 0 POINT 0 1 0 POINT 1 2 0 SIDES 8 ARC 180 CLOSE 0 0 erzeut zwar wieder einen Rotationskörper mit 8 Seiten, rotiert ihn diesmal jedoch nur um 180 Grad. Zusätzlich müssen wir dem System sagen, was es mit den offenen Enden des Rotationskörpers anfangen soll. Hier lassen wir die Enden offen ( close 0 0). Auch Translationsobjekte können entworfen werden. Wir wollen einmal ein Hexagonales Rohr konstruieren: Beispiel: OBJ attribute POINT 0 0 0 POINT 1 1 0 POINT 1 2 0 POINT 0 3 0 POINT -1 2 0 POINT -1 1 0 POINT 0 0 0 ROUTE POINT 0 0 0 POINT 1 1 1 CLOSE 1 1 erzeugt ein hexagonales Rohr, das bei 0 0 0 beginnt und bei 1 1 1 endet, wobei beide Enden geschlossen werden ( 1 1 ). Entlang der Route können Sie optional mit "scale" eien Vergrößerungs- oder Verkleinerungsfaktor eingeben, der das Objekt beim übersetzen kontrahiert oder expandiert. Es gibt genügend Beispiele auf den mitgelieferten Disketten, so auch gz.inp und klein.inp. ----------------------------------------------------------------------- OBJECTS - `OBJEKTE` ----------------------------------------------------------------------- Funktion: Anzeigen der aktuellen Objekte Syntax: OBJECTS :== obj*ects { MSG | SPHERE | QUAD | TRIANGLE | FRACTAL | RING | SUPERQ | TEXT | OBJ | POLY | INSERT }* Erläuterung: Dies sind alle bis jetzt zur Verfügung stehenden Objekte. Für eine detailliertere Beschreibung sehen Sie bitte unter den entsprechenden Kommandos nach. ----------------------------------------------------------------------- PARAMS - `PARAMETER` ----------------------------------------------------------------------- Funktion: Setzen der globalen Parameter Syntax: PARAMS :== par*ameters { MSG | INDEX | PRODUCE | AMBIENT | ANTIALIAS | FOCUS | DIFFUSE | SCAN | BACKGROUND | HAZE | LOOK | INSERT }* Erläuterung: Dies sind alle Einstellungsmöglichkeiten für globale Parameter. Für eine detaillierte Beschreibung sehen Sie bitte unter den entsprechenden Kommandos nach. ----------------------------------------------------------------------- PARS - `OBJEKTPARAMETER` ----------------------------------------------------------------------- Funktion: Bestimmung der Objektparameter Syntax: PARS :== SCALE | ROTX | ROTY | ROTZ | TRAN | PT | RAD SCALE :== sca*le POINT POINT :== [poi*nt] NUM NUM NUM NUM :== fließkomma-zahl ROTX :== rotx NUM [deg*rees] NUM :== fließkomma-zahl ROTY :== roty NUM [deg*rees] NUM :== fließkomma-zahl ROTZ :== rotz NUM [deg*rees] NUM :== fließkomma-zahl TRAN :== tra*nslate POINT POINT :== [poi*nt] NUM NUM NUM NUM :== fließkomma-zahl PT :== point NUM NUM NUM NUM :== fließkomma-zahl RAD :== rad*ius CARD NUM CARD :== integerzahl größer 0 NUM :== fließkomma-zahl Erläuterung: Mit diesem PARS-Kommando beeinflussen Sie sowohl primäre, als auch zusammengesetzte Objekte (Verbundobjekte). Allen Objekten folgt die Angabe: sca*le `Maßstab` legt die Größenverhältnisse in X-, Y- und Z-Richtung fest (Nicht die 0 verwenden!). rotx `RotationX` Dreht das Objekt um die X-Achse (in Grad) roty `RotationY` Dreht das Objekt um die Y-Achse (in Grad) rotz `RotationZ` Dreht das Objekt um die Z-Achse (in Grad) tra*nslate `verschieben` Verschiebt das Objekt in X-, Y- und Z-Richtung Egal welche Reihenfolge Sie diesen Befehlen geben werden Sie dennoch IMMER in der Reihenfolge sca*le, rot.., tra*nslate ausgeführt. Dies ist wegen der Einbindung von Makros notwendig. Die Reihenfolge der Rotationen spielt jedoch eine große Rolle!! rotx 45 roty 45 und roty 45 rotx 45 ergeben verschiedene Resultate. Spielen Sie dies mal mit einem Gegenstand des täglichen Lebens durch! Jedes Objekt beginnt mit zwei Einheitsvektoren (Ursprung in 0, einer in X-Richtung, einer in Y-Richtung). Alle der oben genannten Manipulationen arbeiten mit diesen Vektoren. Wenn Sie z.B. einen Quader von 1000x1000 Seitenlänge mit Lage im Ursprung 0 0 0, der flach auf der X-Z-Ebene liegt (Y=0) könnten Sie folgendes schreiben: Beispiel: quad attribute scale 1000 1000 1 rotx 90 trans -500 0 -500 point `Punkt` Wenn Sie mit etwas andrem als den senkrechten Einheitsvektoren arbeiten wollen, können Sie das PT-Kommando verwenden: Beispiel: quad attribute point -500 0 -500 point 500 0 -500 point -500 0 500 Damit erhalten Sie das selbe Ergebnis wie oben. rad*ius `Radius` Für Objekte, für die ein Radius benötigt wird, können Sie den rad*ius-Befehl verwenden: Beispiel: sphere attribute radius 1 100 ring attribute radius 0 50 radius 1 100 Damit wird eine Kugel mit Radius 100 und ein Ring mit äußerem Radius 100 und innerem Radius 50 erzeugt. Dabei hat der äußere Radius immer die 1 vorangestellt, der innere immer die 0. ----------------------------------------------------------------------- PEBBLE - `KIESELSTEIN` ----------------------------------------------------------------------- Funktion: Definieren einer Kies-Textur Syntax: PEBBLE :== peb*ble [scale] NUM [zoom] NUM NUM :== fließkomma-zahl Erläuterung: Diese Textur gleicht der Schneefall-Textur. Sie befindet sich noch in der Entwicklungsphase. Damit wird angestrebt, eine Art Störfunktion zu implementieren, die aus einer Objektoberfläche einzelne Punkte zufällig "herauszoomt" und damit eine Art Kies- bzw. Sandpapieroberfläche erzeugt. Eine typische Oberfläche wäre: Beispiel: pebble scale 1.0 zoom 0.5 ----------------------------------------------------------------------- POLY - `POLYGON` ----------------------------------------------------------------------- Funktion: Definition eines Polygones aus mehreren Punkten Syntax: POLY :== poly ATTNAME PARS ATTNAME :== alphanumerischer name PARS :== SIEHE PARS-KOMMANDO Erläuterung: Mit diesem POLY-Kommando können Sie jeden gewünschten, geschlossenen Polygon aus mehreren einzelnen Punkten konstruieren. Mit Hilfe des point-Befehles aus dem PARS-Kommando werden diese Punkte im Raum bestimmt. Natürlich funktionieren die sca*le, rot.. und tra*nslate-Befehle auch hier: Beispiel: poly attribute point 0 0 0 point 1 1 0 point 1 2 0 point 0 3 0 point -1 2 0 point -1 1 0 Damit wird ein Hexagon aufgebaut. ----------------------------------------------------------------------- PRODUCE - `ERZEUGEN` ----------------------------------------------------------------------- Funktion: Erzeugung eines 2D-Berechnungszeit-Histogrammes Syntax: PRODUCE :== pro*duce HI HI :== his*togram | ima*ge Erläuterung: Normalerweise enthält das .TMP-File, das der Ray Tracer erzeugt, die binären Pixelwerte der beschriebenen Scene. Um aber z.B. eine Antialiasing-Scene in der Rechenzeit beschleunigen zu können, können Sie dieses PRODUCE-Kommando in Ihr .INP-File mit einbinden. Haben Sie dies getan, wird das Bild-File nicht die Farben der berechneten Scene enthalten, wie sonst, sondern ein zweidimensionales Histogramm, das anzeigt, wie viel Rechenzeit jedes einzelne Pixel in der Scene benötigt. Die benötigte Rechenzeit wird als Grauwert angezeigt. Je heller ein Pixel in diesem Bild erscheint, um so mehr Rechenzeit wird für diesen Bildpunkt benötigt. Beachten Sie jedoch, daß dieses Kommando nur dann sinnvol ist, wenn Sie gleichzeitig das ANTIALIASING-Kommando oder andere rechenintensive Befehle verwenden. Ansonsten wird für jeden Pixel die gleiche Rechenzeit verwendet und dieses Histogramm wäre damit einheitlich grau. Das ANTIALIASING-Kommando aber z.B. sagt dem Ray Tracer, sich auf bestimmte Details der Scene zu konzentrieren, um dann alias-freie Bilder zu zeigen. Beispiel: produce histogram Startet diesen Prozess und gibt dieses 2D-Histogramm anstelle der Scene selbst aus. Beispiel: produce image Zeigt wieder das Bild selbst an. ----------------------------------------------------------------------- QUAD - `QUADER` ----------------------------------------------------------------------- Funktion: Erzeugen eines Parallelogram-Quaders Syntax: QUAD :== qua*d ATTNAME PARS ATTNAME :== alphanumerischer name PARS :== SIEHE PARS-KOMMANDO Erläuterung: Mit diesem Kommando können Parallelogram-Quader geschaffen werden. Sehen Sie unter ATTRIBUTES und PARS für eine genauere Erklärung nach. ----------------------------------------------------------------------- RING - `RING` ----------------------------------------------------------------------- Funktion: Erzeugen eines Rings oder Ringkanales Syntax: RING :== rin*g ATTNAME PARS ATTNAME :== alphanumerischer name PARS :== SIEHE PARS-KOMMANDO Erläuterung: Ringe sind Objekte wie Quader oder Parallelogram-Quader. Sehen Sie unter ATTRIBUTES und PARS für eine genauere Beschreibung nach. ----------------------------------------------------------------------- SCAN - `` ----------------------------------------------------------------------- Funktion: Syntax: SCAN :== sca*n [out*put] [lin*es] NUM NUM [row*s CARD] [col*umns CARD] [mode MODE] [bpp BPP] NUM :== fließkomma-zahl CARD :== integerzahl größer oder gleich 0 MODE :== 0 | 1 | 2 BPP :== 4 | 8 Erläuterung: Wenn dieses Kommando unterlassen wird, wird die vollständige Bitmap des Bildes berechnet (alle 400 Bildschirmzeilen). Dieses Kommando beschreibt nun die Möglichkeit, das Bild in einzelne Bereiche aufzuteilen. Anmerkung des Übersetzers: Leider stimmt in der englischen Anleitung die Beschreibung des Befehles wieder einmal nicht mit der oben angegebenen Syntax überein. Wahrscheinlich wurde die Syntax der neuen Version überarbeitet, ohne jedoch dessen Beschreibung ebenfalls zu überarbeiten. Hier nun die wörtliche Übersetzung der Beschreibung. Vielleicht können Sie durch ausprobieren hinter die tatsächliche Bedeutung der Syntax kommen. Dieses Kommando sagt dem Programm, nur die Zeilen FIRST (`ERSTE`) bis einschließlich LAST-1 (`LETZTE-1`) zu erzeugen. Haben Sie dies einmal getan, können die daraus resultierenden Fragmentbilder wieder zu einem ganzen zusammengesetzt werden. Auf diese Art und Weise kann eine möglicherweise komplexe Scene auf mehrere CPUs (Rechner) aufgeteilt werden, was natürlich insgesamt die Zeit für die Erzeugung dieses Bildes beträchtlich reduziert. Die Zusammensetzung der einzelnen Bildteile geschieht dann mit RAY2. Der RESOLUTION-Wert`AUFLÖSUNG` kontrolliert die MAXIMALE Zeit, die einer Berechnung des gesamten Bildes zur Verfügung gestellt wird. Diese Zahl sollte normalerweise zwischen 1.0 und 30.0 Stunden liegen. Je mehr Zeit Sie dem Bild geben, um so schöner wird das Bild. ----------------------------------------------------------------------- SNOW - `SCHNEE` ----------------------------------------------------------------------- Funktion: Definieren einer "verschneiten" Textur Syntax: SNOW :== sno*w [SRFT] NUM [SRFT] NUM [SRFT] NUM [SRFT] NUM SRFT :== sta*rt | ran*ge | fac*tor | thr*eshold NUM :== fließkomma-zahl Erläuterung: Diese Texturfunktion gleicht dem BLEND-Kommando weiter oben. Es befindet sich jedoch noch in der Entwicklungsphase. Es wird angestrebt, diese Funktion mit Fractal-Oberflächen zusammen zu verwenden, wie weiter unten beschrieben wird. Die Theorie ist dabei, Schnee auf einer Oberfläche zu verteilen, wobei das "wie" von der Steigung und der Höhe der lokalen Oberfläche abhängt. sta*rt `Start` gibt dabei an, ab welcher Höhe der "Schneefall" beginnen soll. Unterhalb diesem Level befindet sich dann kein Schnee auf der Oberfläche, nicht einmal auf ebenen Flächen. ran*ge `Bereich` gibt an, in welchem Bereich der Schnee auf der Oberfläche immer dichter mit wachsender Höhe wird. Ab start+range ist die Oberfläche vollkommen mit Schnee bedeckt. fac*tor `Höhenfaktor` legt den Einfluß der Höhe auf den Schneefall fest. Ein Wert von 0 besagt, daß die Dichte des Schnees nur von der Steigung der Oberfläche abhängt, Werte über 1.0 bewirken einen schnelleren Aufbau der Schneedichte auf der Oberfläche am unteren Ende des Schneefallbereiches (range). thr*eshold `Schwellwert` kontrolliert, ab wann eine Oberfläche komplett mit Schnee bedeckt ist, nachdem die Berechnung den Schwellwert passiert hat. Ein Wert von 0.0 bewirkt, daß die gesamte Oberfläche ab sta*rt mit Schnee bedeckt wird, unabhängig der Steigung der Oberfläche. Ein Wert von 1.0 bedeckt die Oberfläche als eine reine Funktion der Steigung und der Höhe. Werte um 0.4 bewirken z.B., daß alles mit weniger als 40 Grad Steigung unabhängig von der Höhe bedeckt wird. ----------------------------------------------------------------------- SPHERE - `KUGEL` ----------------------------------------------------------------------- Funktion: Definieren einer 3-dimensionalen Sphäre (z.B.Kugel) Syntax: SPHERE :== sph*ere ATTNAME PARS ATTNAME :== alphanumerischer name PARS :== SIEHE PARS-KOMMANDO Erläuterung: Hiermit wird eine 3-dimensinale Sphäre (Kugel, Hohlkugel) definiert. Für die genauere Beschreibung sehen Sie bitte unter dem PARS-Kommando und dem ATTRIBUTES-Kommando nach. ----------------------------------------------------------------------- SUPERQ - `SUPERQUADER` ----------------------------------------------------------------------- Funktion: Definieren eines Superquaders Syntax: SUPERQ :== sup*erquad ATTNAME PARS eps*ilons NUM NUM ATTNAME :== alphanumerischer name PARS :== SIEHE PARS-KOMMANDO Erläuterung: Hiermit wird ein 3-dimensinaler Superquader definiert. Für die genauere Beschreibung sehen Sie bitte unter dem PARS-Kommando und dem ATTRIBUTES-Kommando nach. Superquader sind eine Art von 3-dimensionalen Objekten, die Kegel, Sphären, Pyramieden, Kristalle, Zylinder und eine unendliche Zahl von anderen Objekten beinhalten. Diese sind sehr schwierig zu berechnen und Sie sollten deshalb sparsam mit deren Gebrauch sein. eps*ilons mit seinen zwei Parametern beschreibt die Gestalt dieser Körper. Die aktuelle Gleichung für diese Körper wird durch folgende Formeln beschrieben: e1 e2 x = cos w * cos p e1 e2 y = cos w * sin p e1 z = sin w Die Parameter "w" und "p" laufen dabei von -¶ (Pi) bis +¶. Mit e1=e2=1.0 erhalten Sie eine Kugel. Typische eps*ilon-Werte liegen zwischen 0.5 und 2.0. Sehen Sie sich das Beispiel SQ.INP auf der Diskette an. Sie finden darin einige Beispiele. Außerdem können Sie noch Ihre Mathematikbücher aus der Schulzeit heranziehen, um die e1 und e2 Werte für weitere Formen zu erhalten. ----------------------------------------------------------------------- TEXT - `TEXT` ----------------------------------------------------------------------- Funktion: Definieren eines Textstring-Objektes Syntax: TEXT :== tex*t QUOTE [two*D] [three*D] ATTNAME PARS QUOTE :== "text in anführungsstrichen" ATTNAME :== alphanumerischer name PARS :== SIEHE PARS-KOMMANDO Erläuterung: Sie können mit diesem Kommando ein Textstring-Objekt erzeugen. Für die genauere Beschreibung sehen Sie bitte unter dem PARS-Kommando und dem ATTRIBUTES-Kommando nach. Der Text wird 2- oder 3-dimensional dargestellt (normal 3D). Jeder Buchstabe hat die Standardgröße 1x1x1 und wird mit Startpunkt 0 0 0 entlang der X-Achse geschrieben. Der String "Dies ist ein Text" wird in einem Bereich von 0 0 0 bis 17 1 1 angezeigt. ----------------------------------------------------------------------- TEXTURES - `TEXTUREN` ----------------------------------------------------------------------- Funktion: Definieren von Texturen Syntax: TEXTURES :== tex*tures { MSG | WAVES | BLEND | SNOW | CHECK | MARB | WOOD | PEBBLE | IFF | INSERT }* Erläuterung: Für die Erklärung der einzelnen Texturen sehen Sie bitte unter diesen Kommandos nach. ----------------------------------------------------------------------- TRIANGLE - `DREIECK` ----------------------------------------------------------------------- Funktion: Definieren von Dreiecken Syntax: TRIANGLE :== tri*angle ATTNAME PARS ATTNAME :== alphanumerischer name PARS :== SIEHE PARSKOMMANDO Erläuterung: Die Syntax ist die gleiche wie bei Parallelogrammen, mit der Ausnahme, daß hier die VE und VP-Vektoren die beiden Seiten des Dreieckes kontrollieren. ----------------------------------------------------------------------- WAVES - `WELLEN` ----------------------------------------------------------------------- Funktion: Definieren von Wellen-Quellen Syntax: WAVES :== waves [cen*ter] POINT [WADP] NUM [WADP] NUM [WADP] NUM [WADP] NUM POINT :== [poi*nt] NUM NUM NUM NUM :== alphanumerische-zahl WADP :== wav*elength | amp*litude | dam*ping | pro*pagate NUM :== alphanumerische-zahl Erläuterung: Zahlreiche Programme verwenden die Wellen-Quellen als Basis für Ihre Berechnungen (die meisten benötigen hierfür die geriffelte Oberfläche, wie es sie eben bei Wasser gibt). Sie können bis zu 100 solcher Quellen pro Scene definieren. Es wird jedoch nur eine "Wellentabelle" vom Programm abgespeichert, d.h. daß alle Programme, die Wellenquellen benötigen auf die gleichen Wellen zurückgreifen. Die ersten drei Werte geben die Koordinaten des Ursprunges der konzentrischen Wellenfront an. wav*elength `Wellenlänge` gibt die Länge von Wellenberg zu Wellenberg an. amp*litude `Amplitude` gibt auf abstrakte Art die Höhe der Welle im Ursprung an. Die Höhe wird jedoch nicht in normalen Entfernungseinheiten angegeben, sondern ist ein fest vorgegebenes Spektrum von 0.1 (kleine, flache Wellen) bis 0.5 (starke Wellen). dam*ping `Dämpfung` Dieser Wert kontrolliert die Dämpfung der Wellenausbreitung in Ihrer Höhe. 1.0 bedeutet keine Dämpfung, d.h. die Wellen breiten sich ungehindert aus und verändern Ihre Höhe nicht. Ein Wert von 0.7 bedeutet, daß der folgende Wellenberg 70% der Höhe des letzten Wellenberges hat. pro*pagate `Ausbreitung` Damit wird die Startphase der Ausbreitung kontrolliert. 0.0 bedeutet, daß die Welle im Ursprung mit einem Wellenkamm beginnt, 0.5 mit dem Wellental (180 Grad Phasenwinkel weiter) und 1.0 wieder mit dem Wellenberg. Dies kann z.B. in Bildersequenzen dazu verwendet werden, Wellenbewegungen zu simulieren. ----------------------------------------------------------------------- WOOD - `HOLZ` ----------------------------------------------------------------------- Funktion: Definition einer Holz-Textur Syntax: WOOD :== woo*d COLOR-TIUS COLOR-TIUS :== [col*or] [RGB] NUM [RGB] NUM [RGB] NUM [TIUS] NUM [TIUS] NUM [TIUS] NUM [TIUS] NUM RGB :== red | gre*en | blu*e NUM :== alphanumerische-zahl TIUS :== thi*ckness | rin*g | tur*bulence | squ*eeze Erläuterung: Sie können bis zu zehn Holztexturen pro Scene definieren. Auch diese Textur benötigt dabei mindestens eine Wellenquelle, wie auch z.B. die Marmortextur weiter oben. Bis jetzt sieht die Holztextur der Marmortextur in der Tat noch sehr ähnlich, mit der Ausnahme, daß die marmorene Struktur aus parallelen Streifen des Basismateriales besteht, während die hölzerne Struktur aus konzentrischen Zylindern besteht (entlang der Y-Achse). rin*g ist die Analogie zu xscale beim Marmor; tur*bulence und squ*eeze sind die selben. thi*ckness `Dicke` kontrolliert, wie schwach oder heftig die Maserung wiedergegeben wird. Werte über 1.0 verstärken, solche unter 1.0 dämpfen die Maserung === Anhang A Syntax === *********************************************************************** Alle Komentare können wie in einem C-Compiler eingegeben werden. Liste der vom Compiler ignorierten Worte a along an and as at be by define do equals from he i in is it make my of our set she to the that this then up upto use uses using we would will with you *********************************************************************** AD :== ape*rture | dis*tance AMBIENT :== amb*ient [prop*ortional] [fact*or] NUM ANTIALIAS :== ant*ialias [CT] NUM [CT] NUM ATTNAME :== alphanumerischer name ATTRIBUTE :== attrib*ute ATTNAME [TFMI] NUM [TFMI] NUM [TFMI] NUM [TFMI] NUM [tra*nsparency] POINT [amb*ient] POINT [dif*fuse] COLOR ATTRIBUTES :== att*ributes {TEXT | ATTRIBUTE | FRACT | INSERT } BACKGROUND :== bac*kground COLOR BEGIN :== 0 | 1 BLEND :== ble*nd COLOR-SR BPP :== 4 | 8 CARD :== integerzahl größer oder gleich 0 CHECK :== che*ck COLOR [wid*th] [siz*e] POINT COLOR :== [col*or] [RGB] NUM [RGB] NUM [RGB] NUM COLOR-D :== [col*or] [RGB] NUM [RGB] NUM [RGB] NUM [dis*tance] NUM COLOR-SR :== [col*or] [RGB] NUM [RGB] NUM [RGB] NUM [SR] NUM [SR] NUM COLOR-TIUS :== [col*or] [RGB] NUM [RGB] NUM [RGB] NUM [TIUS] NUM [TIUS] NUM [TIUS] NUM [TIUS] NUM COLOR-XTS :== [col*or] [RGB] NUM [RGB] NUM [RGB] NUM [XTS] NUM [XTS] NUM [XTS] NUM CT :== cou*nt | thr*esh DIFFUSE :== dif*fuse [lig*hting] [SDO] NUM [SDO] NUM [SDO] NUM DIRECTIONAL :== dir*ectional COLOR POINT DR :== [dis*tance] | [rad*ius] END :== 0 | 1 FOCUS :== foc*us [AD] NUM [AD] NUM FRACT :== fra*ctal [rec*ursion] NUM [sca*le] POINT FRACTAL :== fra*ctal [rec*ursion] NUM [sca*le] POINT [fin*altexture] NUM HAZE :== haz*e COLOR-D HI :== his*togram | ima*ge IFF :== iff [siz*e] NUM NUM [edge] NUM NUM [fil*ename] QUOTE IMPORT :== imp*ort FILE INDEX :== ind*ex [ref*raction] NUM INSERT :== MACRO [PARS] LIGHTS :== lig*hts { MSG | DIRECTIONAL | SPHERICAL | INSERT}* LOOK :== loo*k POINT POINT POINT MACDEF :== macro NAME { TOKEN }* done NAME MACRO :== alphanumerischer macroname MACS :== mac*ros { MSG | IMPORT | MACDEF }* MARB :== mar*ble [vei*n] COLOR-XTS MODE :== 0 | 1 | 2 MSG :== "text in anfürungsstrichen" NAME :== alphanumerischer name NUM :== fließkomma-zahl OBJ :== obj*ect ATTNAME PARS OBJTYP OBJECTS :== obj*ects { MSG | SPHERE | QUAD | TRIANGLE | FRACTAL | RING | SUPERQ | TEXT | OBJ | POLY | INSERT }* OBJROT :== [side*s NUM] [arc NUM] [clo*se BEGIN END] OBJROUTE :== route { PT [sca*le NUM] }* [clo*se BEGIN END] OBJTYP :== OBJROUTE | OBJROT PARAMS :== par*ameters { MSG | INDEX | PRODUCE | AMBIENT | ANTIALIAS | FOCUS | DIFFUSE | SCAN | BACKGROUND | HAZE | LOOK | INSERT }* PARS :== SCALE | ROTX | ROTY | ROTZ | TRAN | PT | RAD PEBBLE :== peb*ble [scale] NUM [zoom] NUM POINT :== [poi*nt] NUM NUM NUM POLY :== poly ATTNAME PARS PRODUCE :== pro*duce HI PT :== point NUM NUM NUM QUAD :== qua*d ATTNAME PARS QUOTE :== "text in anführungsstrichen" RAD :== rad*ius CARD NUM RING :== rin*g ATTNAME PARS RGB :== red | gre*en | blu*e ROTX :== rotx NUM [deg*rees] ROTY :== roty NUM [deg*rees] ROTZ :== rotz NUM [deg*rees] SCALE :== sca*le POINT SCAN :== sca*n [out*put] [lin*es] NUM NUM [row*s CARD] [col*umns CARD] [mode MODE] [bpp BPP] SDO :== sam*ples | div*ide | ove*r SNOW :== sno*w [SRFT] NUM [SRFT] NUM [SRFT] NUM [SRFT] NUM SPHERE :== sph*ere ATTNAME PARS SPHERICAL :== sph*erical COLOR [cen*ter] POINT [DR] NUM [DR] NUM SR :== sta*rt | ran*ge SRFT :== sta*rt | ran*ge | fac*tor | thr*eshold SUPERQ :== sup*erquad ATTNAME PARS eps*ilons NUM NUM TEXT :== "text in anführungsstrichen" TEXT :== tex*t QUOTE [two*D] [three*D] ATTNAME PARS TEXTURES :== tex*tures { MSG | WAVES | BLEND | SNOW | CHECK | MARB | WOOD | PEBBLE | IFF | INSERT }* TFMI :== tex*ture | fuz*ziness | mir*ror | ind*ex TOKEN :== beliebige definitionen TRAN :== tra*nslate POINT TRIANGLE :== tri*angle ATTNAME PARS WADP :== wav*elength | amp*litude | dam*ping | pro*pagate WAVES :== waves [cen*ter] POINT [WADP] NUM [WADP] NUM [WADP] NUM [WADP] NUM WOOD :== woo*d COLOR-TIUS XTS :== xsc*ale | tur*bulance | squ*eeze *********************************************************************** === Anhang B Texturen === Texturen werden als Integer-Werte angegeben. Textur 0 bedeutet keine Textur (also nur Farbe). Wählen Sie aus den folgenden aus: Wert Texturfunktion ----- --------------- 1: Y-Achsen Farbgraduierung Berechnet die Farbe an jeder Stelle der Oberfläche als eine Funktion der Koordinaten des Y-Wertes. Bei Y=0 beginnend, wechselt die Farbe von rot über blau nach grün und wieder zrück zu rot bei Y=20. Die Farben wiederholen sich alle 20 Y-Einheiten 3: Gescheckt Die Helligkeit der Oberfläche wechseld ständig, so daß der Eindruck einer gescheckten Oberfläche entsteht. Dazu müssen allerdings einige Wellenquellen definiert sein. 4: Wellige Oberfläche Die Oberfläche sieht aus, als wäre Sie kreuz und quer mit Wellen überzogen. Wenn das Objekt Lichtstrahlen reflektiert, werden diese geriffelt. 5: Ziegelstein Das Objekt sieht mit dieser Textur aus, als wäre es aus Ziegeln aufgebaut. Dabei ist ein Ziegel 3 Einheiten hoch, 8 breit und 4 tief, der Mörtel hat eine Dicke von 0.5 Einheiten. Die Farbe der Ziegel wird durch den dif*fuse-Koeffizienten des Objektes festgelegt. Die Farbe des Mörtels ist vorgegeben mit rot 0.99 grün 0.85 und blau 0.8. Die Ziegel sind im Koordinatensystem ausgerichtet. 6: IFF-Bild Mit diesem Wert können sie die Textur aus einem definierten IFF-Bild aufbauen. Das Bild wird laufend wiederholt. 10... Einfache Wellen ..19: Ähnlich der Textur Nr.4, wobei hier die Oberfläche jedoch nur von einer Welle aufgebaut wird. Die 10 Zahlen geben unterschiedliche einzeln definierte Wellen an. 10 gibt die als estes definierte Wellen-Textur an, 11 die zweite usw. 20... Marmor ..29: Verleiht der Oberfläche eine Marmorstruktur. Für die Zahlen gilt hier das gleiche wie bei den Wellen. 40... Holz ..49: Verleiht dem Objekt eine Holzstruktur. Zahlen wie oben 50... Schachbrettmuster ..59: Verleiht dem Objekt eine von 10 definierten Schachmustern. 60... Fraktaloberfläche ..69: Dies ist keine Textur im üblichen Sinne. Diese "Textur" bestimmt, welche Fraktal-Oberfläche dieses Objekt erhalten soll. Dabei kann diese nur für Fraktal-Objekte verwendet werden. 70... Verlaufenlassen ..79: Läßt im Objekt wie beschrieben die Farben zwischen der orginalen und der festgelegten ble*nd-Farbe verlaufen. 80... Schnee ..89: Die einzelnen Schneefall-Texturen werden hier angewendet. 90... Kies ..99: Damit bekommt das Objekt eine Kiesoberfläche. *********************************************************************** ******************************* * * * Text aus der Serie * * (c) GERMAN (Copyright) * * RHEIN-MAIN-SOFT * * Oberursel * * * *******************************