Texturen Stretchen mit Directx9 (2D Game)

[DX9_Type]

Hallo alle!!

Ich bin daran ein 2D Game mit directX9 zu machen. Ich würde gerne verschiedenen Auflösungen bereitstellen und wollte die Texturen stretchen. Habe allerdings keine Funktion gefunden. Habe auch schon in verschiedenen Foren gelesen, dass mann die Surface selber stretchen kann, habe aber kein schlauen Code gefunden oder ein Tutorial. Darum bitte ich hier um Hilfe.

Meine Klisonsabfrage sollte dann so geschehen dass von einem Bild zum beispeil "Gegner, Player, Schüsse, Wände" die Farbpixel mit einem Array durchgegengen werden, ausgeschnitten und in ein grosses Array gepackt wird und mit Anderen Gegenstände verglichen wird. Nur so zur Info, vieleicht ist dies wichtig für die vorgehensweise.

Währe nett wenn mir hier Jemand ein Tipp geben könnte wie ich dass am besten mache.

[Aramis]

Was meinst du mit 'stretchen' und 'verschiedenen Aufloesungen bereitstellen'? Der Sinn und Zweck verschiedener Aufloesungen ist es ja, unterschiedlichen Detailgrad zur Verfuegung zu stellen. Aber durch das Strecken des Spielinhaltes erreichst du das ja nicht … ganz davon abgesehen, dass du einfach nur den Displaymode auf eine hoehere Aufloesung setzen muesstest - dann werden alle Bildinhalte eigentlich automatisch gestreckt.

Wie zeichnest du denn deine 'Texturen'? Wenn es sich um 2 Dreiecke mit einer Textur drauf handelt, musst du, um die Textur relativ zu anderen Elementen zu strecken, letzlich nur das Rechteck groesser machen, dann kuemmert sich die Grafikhardware um die Interpolation des Texturbilds.

Oder zeichnest du direkt in ein Surface rein? In dem Fall muesstest du bei von der Rasterung deiner Bitmaps abweichenden Aufloesungen tatsaechlich manuell 'strecken' (z.b. via StretchRect). Aber das wiederrum waere nur unnoetig umstaendlich …

also, mehr Informationen bitte :-)

[Krishty]

Du musst aber den richtigen Filtertyp angeben damit nicht interpoliert wird (dann würden sich ja die Farben ändern und u.U. die Kollisionsabfrage versagen) und sicher sein, dass die Formate auf dem Zielsystem unterstützt werden. Quelltext poste ich dir dafür keinen, aber die fünf Parameter sollten ja wohl kein Problem sein (Tipp: IDirect3DTexture9::GetSurfaceLevel()).

Gruß, Ky

[eXile]

Ich nehme an -- zumindest lese ich das aus dem Beitrag vom Threadersteller und Krishtys Antwort heraus -- dass etwas größere Probleme bei der Umsetzung vorliegen: Man sollte immer eine strikte Trennung der graphischen Ausgabe und der Kollisionserkennung erhalten. Das wird spätestens dann notwendig, wenn man komplexere Kollisionserkennungen einbauen möchte, oder Datenstrukturen zur Beschleunigung der Kollisionserkennung einbauen möchte.

Eine Textur zu verzerren ist doch eigentlich (fast) gar nicht notwendig: Wenn man auf dem Bildschirm alles via einer orthogonalen Projektionsmatrix anzeigt, und die Vertexkoordinaten auflösungsunabhängig angibt (was eigentlich immer der Fall ist), so muss nichts verzerrt werden -- das erledigt die Renderingpipeline ganz von alleine. Natürlich sollte man auf die dargestellten Längen aufpassen, damit die Texturen nicht verwaschen aussehen.

Oder hast du ein großes screen space quad, auf dem du einfach eine Textur anzeigst?

[DX9_Type]

Ich danke erstmal für die Antworten!!


Aramis hat geschrieben->

Was meinst du mit 'stretchen' und 'verschiedenen Aufloesungen bereitstellen'? Der Sinn und Zweck verschiedener Aufloesungen ist es ja, unterschiedlichen Detailgrad zur Verfuegung zu stellen. Aber durch das Strecken des Spielinhaltes erreichst du das ja nicht … ganz davon abgesehen, dass du einfach nur den Displaymode auf eine hoehere Aufloesung setzen muesstest - dann werden alle Bildinhalte eigentlich automatisch gestreckt.

Sorry, sind wirklich nicht viel Infos die ich gegeben habe. Stretchen ist eigentlich das falsche Wort. Ich meinte eigentlich "resitzen" oder "Skalieren". Es ist so gedacht, ich habe eine Hintergrund-Grafik die zum beispiel auf der höchsten Auflösung 1280x1024 gespeichert ist. Diese Grafik ist für eine Screen-Auflösung von 1280x1024 !! Es geht eigentlich auch um Fenstermodus oder auch kleinere Bildschirmauflösungen, zum beispiel 800x600. Ich würde einfach dieses Bitmap mit 1280x1024 runter Skalieren, so dass ich sie auch in einem Fenster von 800x600 verwenden könnte.

Aramis hatt geschrieben->

Oder zeichnest du direkt in ein Surface rein? In dem Fall muesstest du bei von der Rasterung deiner Bitmaps abweichenden Aufloesungen tatsaechlich manuell 'strecken' (z.b. via StretchRect). Aber das wiederrum waere nur unnoetig umstaendlich …

Krishty hat geschrieben->

Du musst aber den richtigen Filtertyp angeben damit nicht interpoliert wird (dann würden sich ja die Farben ändern und u.U. die Kollisionsabfrage versagen) und sicher sein, dass die Formate auf dem Zielsystem unterstützt werden. Quelltext poste ich dir dafür keinen, aber die fünf Parameter sollten ja wohl kein Problem sein (Tipp: IDirect3DTexture9::GetSurfaceLevel()).

Auf die Funktion StretchRect bin ich schon gestossen, allerdings weiss ich nicht wie ich sie benutzen soll und wie das ganze überhaubt funktioniert. Mann sieht, ich bin leider ein Neuling in diesem Gebiet.

eXile hatt geschrieben->

Ich nehme an -- zumindest lese ich das aus dem Beitrag vom Threadersteller und Krishtys Antwort heraus -- dass etwas größere Probleme bei der Umsetzung vorliegen: Man sollte immer eine strikte Trennung der graphischen Ausgabe und der Kollisionserkennung erhalten. Das wird spätestens dann notwendig, wenn man komplexere Kollisionserkennungen einbauen möchte, oder Datenstrukturen zur Beschleunigung der Kollisionserkennung einbauen möchte.

Es giebt wirklich Grössere Probleme, dass ganze ist Neuland für mich.
Zur Kollisions erkennung: Ich habe es eigentlich schon erklärt aber ich möchte mich ein bisschen besser Ausdrücken. Für die höchste Auflösung 1280x1024 würde mein Konzept eigentlich Aufgehen, wenn ich nur diese Auflösung hätte. Ich würde einfach mein Image laden mit der Bibliothek LodePNG http://members.gamedev.net/lode/projects/LodePNG/. Dann würde ich mit einem Array jeden Pixel Durchgehen und abfragen, ob der Pixel eine normale Farb ist oder die Farbe Pink:"255, 0, 255". Dann würde ich ein Haubt Array machen dass so gross ist wie der Screen, in dass ich alle Elemente reinkopiere zbs. "Player, Wände, Gegner, Schüsse" natürlich ohne der pink-Farbe. Jedes Objekt hat einen Speziellen int-Wert. Mann muss dann das ganze wie ein Bild vorstellen das aus verschiedenen Zahlen Besteht, jedes Objekt hat eine Andere Zahl. Mann könnte dies auch in ein cout-file Ausgeben lassen und es würde wie ein Bild aus Zahlen aussehen. Durch ein For-Schleifengebastel würde ich dann abfragen welches mit Welchem Objekt kollidiert und wass genau Passiert. Das ganze hatte ich mal mit SDL"http://www.libsdl.org/" hinbekommen.
Mein Problem ist eigentlich das ganze Auf verschiedene Auflösungen anzupassen, da ich mit DirectX ein Image nicht mit einem Rect resitzen kann. Ich würde gerne die Bilder resitzen und dann das ganze mit der Farbabfrage durchgehen, jedoch giebt es so etwas mit DirectX nicht.

eXile hatt geschrieben->

Eine Textur zu verzerren ist doch eigentlich (fast) gar nicht notwendig: Wenn man auf dem Bildschirm alles via einer orthogonalen Projektionsmatrix anzeigt, und die Vertexkoordinaten auflösungsunabhängig angibt (was eigentlich immer der Fall ist), so muss nichts verzerrt werden -- das erledigt die Renderingpipeline ganz von alleine. Natürlich sollte man auf die dargestellten Längen aufpassen, damit die Texturen nicht verwaschen aussehen.

Was ist eine "orthogonalen Projektionsmatrix"? Dass wass du da erzählst, wie es alles von aleine Skaliert :shock: !!

Leider habe ich nicht so viel Ahnung von DirectX9!! Ich habe mal ein Framework aufgebaut, Joystick und Audio implementiert, Texturen gezeichnet und mal ein 3D-Modell im Kreis drehen lassen "Wass mir nicht viel bringt beim 2D-Game".

Ich hoffe ihr könnt mir Tipps mit einer erklährung und vieleicht mit Tutorials geben die mich auf die richtige Bahn lenken. Ich hoffe ich muss mein Konzept mit der Kollisionsabfrage nicht ganz über den Haufen werfen oder alles nur auf einer Screen-Auflösung belassen.

[Mr. Heat]

Die vielleicht einfachste Lösung für dich ist, intern mit einer festen Auflösung zu arbeiten. Alles wird auf eine Textur in deiner festen Auflösung gerendert und erst ganz zum Schluss wird diese Textur auf den Bildschirm gezeichnet. Das ist nicht hübsch, weil Verzerrungen auftreten (dein 1280x1024 ist 5:4, viele Bildschirme sind aber 16:9) und weil dein Spiel dann bei höheren Auflösungen leicht unscharf wirkt. Aber es macht die Arbeit für den Entwickler sehr einfach.

Unser Glow arbeitet so.

[DX9_Type]

Okey, ich mach dass glaubs so, und werde bei einer 5:4 auflösung einfach ein schwarzen Balken oben und unten reinrendern. Die Frage ist, wie funktioniert dass. Wie kann ich alles erst auf eine Screenauflösung vorrendern und dann alles auf verschiedene Auflösungen zeichnen?
Könnte einen kleinen Lehrgang vertragen. Würde gern wissen wass für Funktionen mann braucht und wie das ganze ungefähr aufgebaut ist.

[DX9_Type]

Sorry, wahr vieleicht ein bischen frech einen Lehrgang zu verlangen jedoch brauche ich wirklich ein bischen Aufklährung.

Ich habe mich jetzt trozdem umentschieden und will es auf die harte Tour probieren.

eXile hat geschrieben:

Eine Textur zu verzerren ist doch eigentlich (fast) gar nicht notwendig: Wenn man auf dem Bildschirm alles via einer orthogonalen Projektionsmatrix anzeigt, und die Vertexkoordinaten auflösungsunabhängig angibt (was eigentlich immer der Fall ist), so muss nichts verzerrt werden -- das erledigt die Renderingpipeline ganz von alleine. Natürlich sollte man auf die dargestellten Längen aufpassen, damit die Texturen nicht verwaschen aussehen.

Ich würde gerne wissen wass eine orthogonale Projektionsmatrix ist und wie mann soeine erstellt.
Ich würde auch gerne wissen wie man eine ein Vertex auf eine 2DGrafik Benutzt und die Kollisionsabfrage macht.
Kann ich bei der KollisionsabfrageI die Vertexes auf die Farbe des Images anpassen, also erst Abfragen welche Farbe jeder einzelne pixel im Bild hat und dann ein Vertex setzen wenn der Pixel die Farbe "255,0,255" also Pink hat.
Die Grafik würde dann so Aussehen: -dies soll ein Ball darstellen"etwas Owal :roll: ".

00000000000000000
00000011111100000
00001111111110000
00011111111111000
00001111111110000
00000111111100000
00000011111000000
00000000000000000

Die Nullen währen dann Pink und jedes Null rechts,links,über unter uter einem Eins ein Vertex. Dann könnte ich die Kollisionsabfrage genau machen wie ich es wollte und nicht einfach ein Viereck um das Objekt zeichnen wass ungenau währe.
Sehe ich dass richtig oder bin ich auf dem Holzweg?
Könnte es auch sein dass mann bei einer Textur die eckpunkte als Vetexes benutzt und die dann so in die Matrix zeichnet und die dann in der richtigen Auflösung zeichnet, und ich dann die Kollisionsabfrage unabhängig davon machen muss.

Sorry für mein Noobwissen!!! währe cool wenn mich jemand etwas Aufklähren würde.