{
Willkommen zur neunten Lektion. Mittlerweile sollten Sie über gute Kenntnisse von OpenGL verfügen.
„CKER: Wenn nicht, muss es die Schuld meines Übersetzers sein …“
(Myling fügte hinzu: Meine Sünde ist noch größer, haha)
Sie haben alle Details zum Einrichten eines OpenGL-Fensters gelernt.
Erfahren Sie, wie Sie rotierenden Objekten Licht- und Farbmischungen (Transparenz) zuordnen und hinzufügen.
Diese Lektion sollte als Tutorial für Fortgeschrittene betrachtet werden.
Sie erfahren, wie Sie eine Bitmap in einer 3D-Szene verschieben und schwarze Pixel aus der Bitmap entfernen (mittels Farbmischung).
Als nächstes färben Sie die Schwarz-Weiß-Texturen, und schließlich lernen Sie, satte Farben zu erzeugen.
Und mischen Sie Texturen mit unterschiedlichen Farben miteinander, um einen einfachen Animationseffekt zu erzielen.
Wir werden Änderungen basierend auf dem Code aus der ersten Lektion vornehmen. Fügen Sie zunächst einige Variablen am Anfang des Programmquellcodes hinzu.
Aus Gründen der Übersichtlichkeit habe ich den gesamten Code umgeschrieben.
}
Var
h_RC: HGLRC; // Rendering-Kontext (Schattierungsbeschreibungstabelle).
h_DC: HDC; // Gerätekontext (Gerätebeschreibungstabelle)
h_Wnd: HWND; // Fensterhandle
h_Instance: HINST; // Programminstanz (Instanz).
Tasten: Array[0..255] Of Boolean; // Array für Tastaturroutinen
{Die folgenden Zeilen wurden neu hinzugefügt.
twinkle und tp sind boolesche Variablen, das heißt, sie können nur auf TRUE oder FALSE gesetzt werden.
Twinkle wird verwendet, um zu verfolgen, ob der Flimmereffekt aktiviert ist.
Mit tp wird überprüft, ob die Taste „T“ gedrückt oder losgelassen wird.
(tp=TRUE beim Drücken, tp=FALSE beim Loslassen).}
funkeln: Boolean; // Funkelnde Sterne (neu)
tp : Boolean; // Wird 'T' gedrückt (neu)
{Jetzt erstellen wir eine Struktur.
Die Wortstruktur klingt beängstigend, ist es aber nicht. (Dies ist der Datensatztyp von Delphi)
Eine Struktur verwendet eine Reihe einfacher Datentypen (und Variablen usw.), um eine größere Kombination ähnlicher Daten auszudrücken.
Wir wissen, dass wir die Sterne im Auge behalten.
Sie können die Sterne unten sehen;
Jeder Stern hat drei ganzzahlige Farbwerte. Ein Rot (r), ein Grün (g) und ein Blau (b).
Außerdem hat jeder Stern einen anderen Abstand von der Mitte des Bildschirms.
Und es kann ein beliebiger 360-Grad-Winkel mit der Mitte des Bildschirms als Ursprung sein.
Eine Gleitkommazahl von dist, um die Entfernung zu verfolgen.
Eine Gleitkommazahl des Winkels verfolgt den Winkelwert des Sterns.
Deshalb haben wir einen Datensatz verwendet, um die Farbe, Entfernung und den Winkel der Sterne auf dem Bildschirm zu beschreiben.
Leider verfolgen wir mehr als einen Stern.
Es besteht jedoch keine Notwendigkeit, 50 Rotwerte, 50 Grünwerte, 50 Blauwerte und 50 Distanzwerte zu erstellen
und 50 Winkelwerte, und erstellen Sie einfach einen Array-Stern. }
Typ
stars = Record //Erstelle eine Struktur für Sterne und nenne die Struktur Sterne
r, g, b: Ganzzahl; // Farbe der Sterne
dist: GLfloat; // Der Abstand des Sterns vom Zentrum
angle: GLfloat; // Der Winkel des aktuellen Sterns
Ende;
Var
star: Array[0..49] Of stars; // Verwenden Sie die „stars“-Struktur, um ein „star“-Array mit 50 Elementen zu generieren
{Als nächstes richten wir mehrere Tracking-Variablen ein:
Die Abstandsvariable (Zoom) des Sterns vom Beobachter,
Der Winkel (Neigung), in dem wir die Sterne sehen,
und der variable Spin, der den funkelnden Stern dazu bringt, sich um die Z-Achse zu drehen.
Die Schleifenvariable wird zum Zeichnen von 50 Sternen verwendet.
Textur[1] wird zum Speichern einer Schwarz-Weiß-Textur verwendet.
Wenn Sie mehr Texturen benötigen,
Sie sollten die Größe des Texturarrays entsprechend der Anzahl der Texturen erhöhen, die Sie verwenden möchten.
}
zoom: GLfloat = -15.0; // Die Entfernung des Sterns vom Beobachter
Tilt: GLfloat = 90.0; // Die Neigung des Sterns
spin : GLfloat; // Die Rotation des funkelnden Sterns
loop: GLuint; // Globale l-Schleifenvariable
Textur: Array[0..1] Of GLuint; // Eine Textur speichern
PROcedure glGenTextures(n: GLsizei; Var Textures: GLuint);
opengl32;
Prozedur glBindTexture(target: GLenum; texture: GLuint);
opengl32;
{
Der Code direkt darüber ist der Code, den wir zum Laden der Textur verwenden.
Ich werde diesen Code nicht im Detail erklären.
Dies ist genau derselbe Code, den wir in den Lektionen 6, 7 und 8 verwendet haben.
Die diesmal geladene Bitmap heißt star.bmp.
Hier verwenden wir glGenTextures(1, &texture[0]),
um eine Textur zu erzeugen. Die Textur verwendet lineare Filterung.
}
Funktion LoadTexture: boolean; //Bitmap laden und in eine Textur umwandeln
Var
Status: boolean; // Statusanzeige
TextureImage: Array[0..1] Of PTAUX_RGBImageRec; // Texturspeicherplatz erstellen
Beginnen
Status := false;
ZeroMemory(@TextureImage, sizeof(TextureImage)); // Zeiger auf NULL setzen
TextureImage[0] := LoadBMP('Star.bmp');
Wenn TextureImage[0] <> Null, dann
Beginnen
Status := TRUE; // Status auf TRUE setzen
glGenTextures(1, Texture[0]); // Textur erstellen
// Nächste Filterkarte erstellen
glBindTexture(GL_TEXTURE_2D, Textur[0]);
// Textur erzeugen
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0].sizeX,
TextureImage[0].sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE,
TextureImage[0].data);
Ende;
Wenn zugewiesen(TextureImage[0]) Dann // Ob die Textur existiert
Wenn zugewiesen(TextureImage[0].data) Dann // Ob das Texturbild vorhanden ist
TextureImage[0].data := Nil; // Den vom Texturbild belegten Speicher freigeben
TextureImage[0] := Nil; // Bildstruktur freigeben
Ergebnis := Status; // Rückgabestatus
Ende;
{Legen Sie den OpenGL-Renderingmodus in glInit() fest. Wir werden hier keine Tiefentests verwenden,
Wenn Sie den Code aus Lektion 1 verwenden,
Bitte bestätigen Sie, ob glDepthFunc(GL_LEQUAL) und glEnable(GL_DEPTH_TEST) entfernt wurden.
Andernfalls werden die Ergebnisse, die Sie sehen, ein Durcheinander sein.
Hier verwenden wir Textur-Mapping,
Stellen Sie daher bitte sicher, dass Sie Code hinzugefügt haben, der nicht in der ersten Lektion enthalten war.
Sie werden feststellen, dass wir die Texturzuordnung durch Mischen von Farben aktiviert haben.
}
Prozedur glInit();
Beginnen
If (Not LoadTexture) Then // Aufruf der Subroutine zum Laden der Textur (neu)
exit; // Wenn das Laden fehlschlägt, beenden Sie (neu)
glEnable(GL_TEXTURE_2D); // Texturzuordnung aktivieren
glShadeModel(GL_SMOOTH); // Schattenglättung aktivieren
glClearColor(0.0, 0.0, 0.0, 0.5); // schwarzer Hintergrund
glClearDepth(1.0); //Setze den Tiefenpuffer
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Wirklich gute Perspektivenkorrektur
glBlendFunc(GL_SRC_ALPHA, GL_ONE); // Stellen Sie die Farbmischfunktion ein, um einen durchscheinenden Effekt zu erzielen
glEnable(GL_BLEND); // Farbmischung aktivieren
{Das Folgende ist der neue Code.
Der Startwinkel, die Entfernung und die Farbe jedes Sterns werden festgelegt.
Sie werden feststellen, wie einfach es ist, die Eigenschaften einer Struktur zu ändern.
Alle 50 Sterne werden durchlaufen.
Um den Winkel von star[1] zu ändern, müssen wir nur star[1].angle=a bestimmten Wert;
So einfach ist das! }
For-Schleife := 0 bis 49 Do // Eine Schleife erstellen, um alle Sterne zu setzen
Beginnen
star[loop].angle := 0.0; // Alle Sterne beginnen bei einem Winkel von Null
{Der Abstand des Schleifensterns vom Zentrum wird durch den Wert der Schleife durch die Gesamtzahl der Sterne geteilt und dann mit 5,0 multipliziert.
Dies führt im Wesentlichen dazu, dass der letztere Stern etwas weiter von der Mitte entfernt ist als der vorherige Stern.
Wenn die Schleife also 50 ist (der letzte Stern), beträgt die Schleife dividiert durch die Zahl genau 1,0.
Der Grund, warum wir mit 5,0 multiplizieren müssen, liegt darin, dass 1,0*5,0 5,0 ist.
『CKER: Unsinn, Unsinn! Warum sieht dieser Ausländer aus wie Kong Yiji! :)』
5.0 ist bereits sehr nah am Bildschirmrand. Ich möchte nicht, dass die Sterne aus dem Bildschirm fliegen, daher ist 5.0 die beste Wahl.
Wenn Sie die Szene natürlich tiefer in den Bildschirm hinein platzieren,
Vielleicht könnten Sie einen Wert größer als 5,0 verwenden, aber die Sterne würden kleiner aussehen (alles wegen der Perspektive).
Sie werden auch feststellen, dass die Farbe jedes Sterns eine Zufallszahl von 0 bis 255 ist.
Sie fragen sich vielleicht, warum der Farbwertbereich hier nicht dem üblichen OpenGL-Bereich von 0,0 bis 1,0 entspricht.
Die Farbeinstellungsfunktion, die wir hier verwenden, ist glColor4ub anstelle der vorherigen glColor4f.
ub bedeutet, dass der Parameter vom Typ Unsigned Byte ist.
Der Wertebereich eines Bytes liegt zwischen 0 und 255.
Es scheint einfacher zu sein, einen Bytewert zu verwenden, um eine zufällige Ganzzahl zu erhalten, als eine Gleitkomma-Zufallszahl.
}
star[loop].dist := (Trunc(loop) / 50) * 5.0; // Berechne den Abstand des Sterns vom Zentrum
star[loop].r := random(256); // Setze eine zufällige rote Komponente für star[loop]
star[loop].g := random(256); // Setze eine zufällige rote Komponente für star[loop]
star[loop].b := random(256); // Setze eine zufällige rote Komponente für star[loop]
Ende;
Ende;
{
Nun wenden wir uns dem Zeichencode glDraw() zu.
Wenn Sie den Code aus Lektion 1 verwenden, löschen Sie den alten DrawGLScene-Code und kopieren Sie einfach den folgenden Code.
Tatsächlich besteht der Code für die erste Lektion nur aus zwei Zeilen, sodass nicht viel ausgeschnitten werden muss.
}
Prozedur glDraw();
Beginnen
glClear(GL_COLOR_BUFFER_BIT Or GL_DEPTH_BUFFER_BIT); // Bildschirm- und Tiefenpuffer löschen
glBindTexture(GL_TEXTURE_2D, texture[0]); // Textur auswählen
For-Schleife := 0 bis 49 Führen Sie // eine Schleife aus, um alle Sterne zu setzen
Beginnen
glLoadIdentity(); // Vor dem Zeichnen jedes Sterns die Modellbeobachtungsmatrix zurücksetzen
glTranslatef(0.0, 0.0, zoom); // Gehen Sie tiefer in den Bildschirm hinein (mit dem Wert von „zoom“)
glRotatef(tilt, 1.0, 0.0, 0.0); // Betrachtungswinkel neigen (unter Verwendung des Werts von 'tilt')
{
Jetzt lasst uns die Sterne bewegen.
Der Stern beginnt in der Mitte des Bildschirms.
Als Erstes müssen wir die Szene entlang der Y-Achse drehen.
Wenn wir es um 90 Grad drehen, verläuft die X-Achse nicht mehr von links nach rechts, sondern geht von innen nach außen aus dem Bildschirm heraus.
Um es klarer zu machen, geben wir ein Beispiel. Stellen Sie sich vor, Sie stehen mitten in einem Haus.
Stellen Sie sich nun vor, dass auf der Wand zu Ihrer Linken -x und auf der Wand vor Ihnen -z steht.
Die Wand rechts ist +x und die Wand hinter Ihnen ist +z.
Wenn das gesamte Haus um 90 Grad nach rechts gedreht ist, Sie sich aber nicht bewegen, ist die Wand davor -x statt -z.
Alle anderen Wände bewegen sich ebenfalls. -z erscheint rechts, +z erscheint links und +x erscheint hinter Ihnen.
Bist du verrückt? Durch Drehen der Szene ändern wir die Ausrichtung der x- und z-Ebenen.
Die zweite Codezeile verschiebt einen positiven Wert entlang der x-Achse.
Normalerweise bedeutet ein positiver Wert auf der x-Achse eine Bewegung zur rechten Seite des Bildschirms (d. h. in die übliche positive Richtung der x-Achse).
Da wir hier aber das Koordinatensystem um die y-Achse drehen, kann die positive Richtung der x-Achse in jede beliebige Richtung gehen.
Wenn wir es um 180 Grad drehen, werden die linke und rechte Seite des Bildschirms gespiegelt.
Wenn wir uns also entlang der positiven x-Achse bewegen, kann diese nach links, rechts, vorwärts oder rückwärts erfolgen.
}
glRotatef(star[loop].angle, 0.0, 1.0, 0.0); //Auf den Winkel des aktuell gezeichneten Sterns drehen
glTranslatef(star[loop].dist, 0.0, 0.0); // Vorwärts entlang der X-Achse bewegen
{
Der folgende Code hat einen kleinen Trick.
Die Sterne sind eigentlich eine flache Textur.
Jetzt zeichnen Sie ein flaches Quad in der Mitte des Bildschirms und wenden eine Textur an, und es sieht gut aus.
Alles ist so, wie Sie es sich vorgestellt haben. Wenn Sie jedoch um 90 Grad entlang der Y-Achse drehen,
Die einzigen beiden Seiten der Textur auf dem Bildschirm, die Ihnen zugewandt sind, sind die rechte und die linke Seite. Es sieht einfach wie eine dünne Linie aus.
Das ist nicht das, was wir wollen. Wir möchten, dass die Sterne uns immer zugewandt sind, egal wie der Bildschirm gedreht oder geneigt wird.
Dies erreichen wir, indem wir alle am Stern vorgenommenen Drehungen aufheben, bevor wir ihn zeichnen.
Sie können die Drehung umkehren, um der Drehung entgegenzuwirken. Wenn wir den Bildschirm neigen, drehen wir den Stern tatsächlich in seinem aktuellen Winkel.
Indem wir die Reihenfolge umkehren, „drehen“ wir den Stern in seinem aktuellen Winkel „gegen die Drehung“. Das heißt, der Stern wird um den negativen Wert des aktuellen Winkels gedreht.
das heißt,
Wenn wir den Stern um 10 Grad gedreht haben, drehen wir ihn um -10 Grad, sodass der Stern wieder auf dieser Achse zum Bildschirm zeigt.
Die erste Zeile unten bricht die Drehung entlang der y-Achse ab. Dann müssen wir auch die Bildschirmneigung entlang der x-Achse versetzen.
Dazu müssen wir den Bildschirm nur noch einmal drehen und neigen.
Nachdem die Drehung um die x- und y-Achse aufgehoben wurde, ist der Stern nun wieder vollständig uns zugewandt.
}
glRotatef(-star[loop].angle, 0.0, 1.0, 0.0); // Den Winkel des aktuellen Sterns aufheben
glRotatef(-tilt, 1.0, 0.0, 0.0); // Bildschirmneigung abbrechen
{Wenn Twinkle WAHR ist, zeichnen wir zunächst einen nicht gedrehten Stern auf dem Bildschirm:
Subtrahieren Sie die aktuelle Anzahl der Sterne (Schleife) von der Gesamtanzahl der Sterne (num) und subtrahieren Sie dann 1.
um die verschiedenen Farben jedes Sterns zu extrahieren (dies geschieht, weil der Schleifenbereich von 0 bis num-1 reicht).
Wenn das Ergebnis beispielsweise 10 ist, verwenden wir die Farbe des Sterns Nr. 10.
Auf diese Weise sind die Farben benachbarter Sterne immer unterschiedlich. Es ist keine gute Idee, aber es funktioniert.
Der letzte Wert ist die Alphakanalkomponente. Je kleiner der Wert, desto dunkler ist der Stern.
Da Twinkle aktiviert ist, wird jeder Stern am Ende zweimal gezeichnet.
Abhängig von der Leistung Ihres Computers wird das Programm langsamer ausgeführt.
Aber die Farben der in zwei Durchgängen gezeichneten Sterne verschmelzen miteinander und ergeben einen tollen Effekt.
Da sich die Sterne im ersten Durchgang nicht drehten, sehen die Sterne gleichzeitig nach der Aktivierung des Funkelns wie ein Animationseffekt aus.
(Wenn Sie das hier nicht verstehen, sehen Sie sich einfach selbst den Laufeffekt des Programms an.)
Es ist erwähnenswert, dass das Färben von Texturen einfach ist.
Obwohl die Textur selbst schwarz und weiß ist, ändert sich die Textur in die Farbe, die wir vor dem Malen ausgewählt haben.
Darüber hinaus ist es erwähnenswert, dass der hier verwendete Farbwert vom Byte-Typ ist.
anstelle der üblichen Gleitkommazahlen. Sogar die Alphakanal-Komponente ist so. }
If (twinkle) Then // Twinkle-Effekt aktivieren
Beginnen
//Geben Sie eine Farbe mithilfe eines Bytewerts an
glColor4ub(star[(50 - Schleife) - 1].r, star[(50 - Schleife) - 1].g,
star[(50 - Schleife) - 1].b, 255);
glBegin(GL_QUADS); // Beginnen Sie mit dem Zeichnen von texturierten Quads
glTexCoord2f(0.0, 0.0);
glVertex3f(-1.0, -1.0, 0.0);
glTexCoord2f(1.0, 0.0);
glVertex3f(1.0, -1.0, 0.0);
glTexCoord2f(1.0, 1.0);
glVertex3f(1.0, 1.0, 0.0);
glTexCoord2f(0.0, 1.0);
glVertex3f(-1.0, 1.0, 0.0);
glEnd(); // Ende der Viereckszeichnung
Ende;
{
Zeichnen Sie nun den zweiten Durchgang der Sterne.
Der einzige Unterschied zum vorherigen Code besteht darin, dass die Sterne dieses Mal definitiv gezeichnet werden und sich dieses Mal um die Z-Achse drehen.
}
glRotatef(spin, 0.0, 0.0, 1.0); // Den Stern um die z-Achse drehen
//Geben Sie eine Farbe mithilfe eines Bytewerts an
glColor4ub(star[loop].r, star[loop].g, star[loop].b, 255);
glBegin(GL_QUADS); // Beginnen Sie mit dem Zeichnen von texturierten Quads
glTexCoord2f(0.0, 0.0);
glVertex3f(-1.0, -1.0, 0.0);
glTexCoord2f(1.0, 0.0);
glVertex3f(1.0, -1.0, 0.0);
glTexCoord2f(1.0, 1.0);
glVertex3f(1.0, 1.0, 0.0);
glTexCoord2f(0.0, 1.0);
glVertex3f(-1.0, 1.0, 0.0);
glEnd(); // Ende der Viereckszeichnung
{Der folgende Code stellt die Bewegung von Sternen dar.
Wir erhöhen den Spin-Wert, um alle Sterne zu drehen (Umdrehung).
Erhöhen Sie dann den Rotationswinkel jedes Sterns um Schleife/Zahl.
Dies führt dazu, dass Sterne, die weiter vom Zentrum entfernt sind, schneller rotieren. Reduzieren Sie abschließend den Abstand jedes Sterns von der Mitte des Bildschirms.
Es sieht so aus, als würden die Sterne ständig in die Mitte des Bildschirms gesaugt. }
spin := spin + 0,01; // Die Umdrehung des Sterns
star[loop].angle := star[loop].angle + Trunc(loop) / 50; // Drehwinkel des Sterns ändern
star[loop].dist := star[loop].dist - 0.01; // Ändere den Abstand des Sterns vom Zentrum
{In den nächsten Zeilen wird überprüft, ob der Stern die Mitte des Bildschirms berührt hat.
Wenn der Stern die Mitte des Bildschirms erreicht, geben wir ihm eine neue Farbe und verschieben ihn um 5 Einheiten nach außen.
Der Stern tritt seine Reise zurück in die Mitte des Bildschirms an. }
If (star[loop].dist < 0.0) Then // Hat der Stern das Zentrum erreicht?
Beginnen
star[loop].dist := star[loop].dist + 5.0; // 5 Einheiten nach außen verschieben
star[loop].r := random(256); // Eine neue rote Komponente zuweisen
star[loop].g := random(256); // Eine neue grüne Komponente zuweisen
star[loop].b := random(256); // Eine neue blaue Komponente zuweisen
Ende;
Ende;
Ende;
{
Jetzt fügen wir den Code zur Überwachung der Tastatur hinzu.
Gehen Sie nach unten zu WinMain(). Suchen Sie die Zeile SwapBuffers(hDC).
Nach dieser Zeile fügen wir den Tastaturüberwachungscode hinzu.
Der Code prüft, ob die T-Taste gedrückt wurde.
Wenn die T-Taste gedrückt und wieder losgelassen wird, wird der Code im if-Block ausgeführt.
Wenn Twinkle FALSCH ist, wird es WAHR.
umgekehrt. Solange die T-Taste gedrückt wird, wird tp TRUE.
Dadurch wird verhindert, dass der Code innerhalb des Blocks wiederholt ausgeführt wird, wenn Sie die T-Taste weiterhin drücken.
}
If (keys[ord('T')] And Not tp) Then // Ob die T-Taste gedrückt wurde und der tp-Wert FALSE ist
Beginnen
tp := TRUE; // Wenn ja, setze tp auf TRUE
Twinkle := Nicht Twinkle; // Den Wert von Twinkle umdrehen
Ende;
{
Der folgende Code prüft, ob die T-Taste losgelassen wurde.
Wenn ja, setzen Sie tp=FALSE.
Sofern der Wert von tp nicht FALSE ist,
Ansonsten passiert beim Gedrückthalten der T-Taste nichts. Daher ist diese Codezeile wichtig.
}
If (Not keys[Ord('T')]) Then // Wurde die T-Taste losgelassen?
Beginnen
tp := FALSE; // Wenn ja, ist tp FALSE
Ende;
{Der verbleibende Code prüft, ob die Aufwärts- und Abwärtspfeiltasten, die Bild-auf-Taste oder die Bild-ab-Taste gedrückt werden. }
If (keys[VK_UP]) Then // Ist die Aufwärtspfeiltaste gedrückt?
Tilt := Tilt - 0,5; // Neige den Bildschirm nach oben
If (keys[VK_DOWN]) Then // Ist die Abwärtspfeiltaste gedrückt?
Tilt := Tilt + 0,5; // Neige den Bildschirm nach unten
If (keys[VK_PRIOR]) Then // Ist die Bild-auf-Taste gedrückt?
zoom := zoom - 0,2; // Verkleinern
If (keys[VK_NEXT]) Then // Ist die Bild-nach-unten-Taste gedrückt?
zoom := zoom + 0,2; // Vergrößern
{
In dieser Lektion versuche ich mein Bestes zu erklären, wie man eine Graustufen-Bitmap-Textur lädt.
Nachdem Sie die Hintergrundfarbe (mit Mischfarben) entfernt haben, färben Sie sie erneut und bewegen Sie sie schließlich in der 3D-Szene.
Ich habe Ihnen gezeigt, wie Sie wunderschöne Farb- und Animationseffekte erstellen.
Das Implementierungsprinzip besteht darin, eine Bitmap-Kopie mit der Original-Bitmap zu überlappen.
Solange Sie bis jetzt ein gutes Verständnis von allem haben, was ich Ihnen beigebracht habe,
Sie sollten problemlos in der Lage sein, Ihre eigene 3D-Demo zu erstellen.
Alle Grundlagen abgedeckt! }
//========myling:
//Die Vorlesungen 1-9 wurden übersetzt, wie NEHE sagte, das Grundwissen wurde im Wesentlichen erklärt.
//Ich habe mir die folgenden Tutorials angesehen und sie scheinen von anderen Leuten geschrieben worden zu sein. Wenn es gute Beispiele gibt, werde ich ihnen selektiv folgen.
//Erneuert, ich bin so müde, mach ein Nickerchen :), bis zum nächsten Mal