Hallöchen,

ich habe vor, ein kleines 2D-Spiel mittels OpenGL zu erstellen. Dabei bin ich auf eine Vielzahl von Problemen gestoßen. Zum einen erstmal, dass Texturen immer recht verwaschen aussehen. Also etwas unscharf. Wäre ja nicht so schlimm, wenn dadurch nicht die Konturen der Grafiken mit der transparenten Farbe überlaufen würde. Dadurch entstehen dann schwarze Ränder die man nicht wegbekommt:



Links die Szene mit NEAREST-Filter, mittig mit LINEAR-Filter und links so wie es sein soll, ohne glättung, ohne daraus folgende schwarze Ränder.

Es muss doch irgendeine Möglichkeit geben, die Grafiken (übrigends im Targa-Format) 1 : 1 auf den Schirm zu bringen und nicht so per Textur wo alles verwischt. Im 2D-Grafik-Tutorial wird zwar beschrieben, dass es bei solchen Grafiken leider so ist, dass es etwas schwammig wird, aber das kann's doch nicht sein. Sollte OpenGL tatsächlich nicht in der Lage sein, ein Bitmap korrekt ohne Verzug anzuzeigen?

Bisher mach ich das so: (C Code)



In den 3-For-Schleifen wird die Szene aufgebaut, dabei besteht's aus Tiles welche aus einer 640 x 640 Pixel großen Textur entstehen. Diese Textur wird dann immer so zurecht gelegt, dass das passende Teil auf dem 32 x 32 Pixel großen Block angezeigt wird.

mfg.

Sunny

wo kommt die transparenz her ? ist die in den dateien gespeichert, also wie viel alpha ein jedes pixel des bildes hat ? oder machst du das im code ?
die schwarzen render kommen ja daher, dass an der stelle durch das filtering nichtmehr ganz die farbe ist, die als transparente farbe gilt, deshalb wird dort die farbe(ein wenig verwaschen) angezeigt die eigentlich durchsichtig seinen sollte.

PS:das gane ist aber ein standard problem, nimm ma die suchfunktion und du wirst sicher fündig.

_________________
www.extrawurst.org

Das ist eine Targa-Datei, also mit Selektion, was dann später als transparente Farbe nicht angezeigt wird. 4 bit pro Pixel, die transparents entspringt also direkt aus der Datei. Die Alpha-Daten werden ja auch korrekt eingeladen, sieht man da, da nicht alles schwarz ist.
(Die Suchfunktion hat zwar ne Menge ausgespuckt, allerdings meist Sachen die in Verbindung mit Blending stehen, und das wollt ich eigentlich ohne Blending machen).

so, hab eben nachgeschaut, wenn du auf das filtern verzichten kannst mach nach dem binden der texture:

dann ist das schwammige weg und die alpha-verläufe ebenfalls. hab ich bei mir genauso gemacht

_________________
www.extrawurst.org

Wenns ned hilft, versuchs mal mit Anisotropischer Filterung.
Die kannst du auch im Treiber schrittweise erhöhen, schau mal, obs damit vielleicht besser wird. Kostet aber relativ viel Performance.

_________________
"Du musst ein Schwein sein in dieser Welt, sangen die Prinzen, das ist so 1.0. Du musst auf YouTube zeigen, dass dir dein Schweinsein gefällt, das ist leuchtendes, echtes Web 2.0."
- Hal Faber
Meine Homepage: http://laboda.delphigl.com

Also das mit den schwarzen Rändern:
Entweder:
glAlphaFunc(GL_GEQUAL, 1.0f);

Oder:
Versuche die Hintergrundfarbe nicht schwarz zu machen sondern möglichst den Farben der Ränder anzupassen. ZB indem du bei allen Texeln wo ein Übergang zwischen Undurchsichtig und durchsichtig existiert einfach die Farbe des sichtbaren Nachbarpixels verwenden.

Deine Texturcoordinatenberechnungen lassen darauf schließen, dass du ne 640x640 Textur verwendest?
Ich nehme an du verwendest zum erstellen der Textur die gluBuild2DMipmaps-Funktion? Dir ist klar das bei dieser Funktion die Texturen auf die nächst höhere 2er-Potenz gescaled werden? Und da du beim Zeichnen nun wiederum 1024/640 = 1,6 Texel / Pixel hast wird er wahrscheinlich das 1te Texturlevel mit geringerem Level of Detail verwenden anstatt des 0ten. Also wenn möglich versuch sattdessen zB 512x512 Texturen zu verwenden.

Zusätzlich sollte dir (vor allem bei den Gras Tiles und dergleichen) bewusst sein, dass eine derartige Texturcoordinatenangabe auch einen kleinen Teil der Farben des nachbar-Tiles innerhalb der Textur verwendet, das würd jetz aber wohl den Rahmen sprengen da es etwas kompliziert zum erklären ist ...

Ah, vielen Dank, es war tatsächlich die Tatsache, dass meine Textur keine 2er Potenz hatte und deshalb gestretcht wurde. Dann wurden die Ränder eben alle schwarz. Wenn ich jetzt 512 x 512er Sprites verwende klappts. Damit hat sich jetzt das Problem mit der Unschärfe und den schwarzen Rändern zugleich gelöst. Zwar etwas dumm, dass es immer 2er Potenzen sein müssen, aber da kann man wohl nichts machen, wie?
Rein Interessehalber, muss es in DirectX auch ein Bild in 2er Potenzen sein?

Du könntest eine 1024x1024 Textur verwenden wo nur ein 640x640 Teil verwendet wird ... wär halt etwas Ressourcen-verschwenderisch.


Wie heißts so schön? Die kochen auch nur mit Wasser. Das es 2er Potenzen sein müssen hängt mit der Hardware zusammen. In OGL gibt es eine Extension wo du Rechteckige / nicht 2er Potenz - Texturen verwenden kannst, in den neueren DX Versionen wirds das sicher auch geben. Aber nur damit es ein bisschen komfortabler zum zeichnen oder programmieren wird, Grafikkarten mit speziellen Features voraussetzen halte ich persönlich nicht für sonderlich toll.

(ARB|NV|EXT)_texture_rectangle werden doch von fast allen Karten unterstützt. Allerdings hat man kein Mipmapping und muß die Koordinaten in Pixeln und nicht von 0..1 angeben, was bei 2D Bilder auch von Vorteil sein könnte. Man verwendet dann GL_TEXTURE_RECTANGLE statt GL_TEXTURE_2D, als Paramter beim Texture Target. Der Wert dieser Konstante ist für alle drei Extensions gleich.
In Direct3D gibt es ein Caps Bit, dass angibt ob solche Texturen akzeptiert werden. Dort übergibt man die rechteckige Texture dann als normale Texture. Da sich bei OpenGL aber die Addressierung ändert, wurde ein extra Texture Target eingerichtet, dass man übrigens auch mit glEnable aktivieren muß.

Könntest du dazu noch paar Worte verlieren. Das interessiert mich, da meine Texturen immer leichte Ränder haben.

_________________
Blog: kevin-fleischer.de und fbaingermany.com

Will an dieser stelle nur mal eben nen Link reinwerfen:



Ich hatte auch mal das Problem, und dieses Tut war mir auf ne große Hilfe:

:http://www.vterrain.org/Plants/Alpha/index.html

Das beschreibt genau dieses Ränderverwischen.

Ok ich werds mal kurz und bündig versuchen :-).

Generell werd ich mich nur auf 1D Texturen beziehen, ist genau so für alle weiteren Dimensionen anwendbar.

Stell dir deine Textur mal als Funktion von s-Koordinate auf Farbwert vor. Du hast bei deiner Textur nur für Texturgröße s-Koordinaten den genauen Farbwert gegeben, die s-Koordinate soll jedoch beliebig sein (zB float Genauigkeit).
Wenn du nun bei einer Nearest-Funktion das Bedürfniss hast, das jeder Texel einen gleich großen Bereich abdeckt, dann nimmt jedes Texel einen Bereich von 1 / Texturgröße ein. Bei einem Nearest erwartest du, dass 0.0 ganz links und 1.0 ganz rechts in der Textur ist, das ist jedoch zusammen mit den oberen Voraussetzungen nur dann möglich, wenn sich das Zentrum (also die s-Koordinate für den das 1. Texel der Textur bestimmt ist) genau an der Position (1 / Texturgröße) / 2, also in der Mitte des Bereiches den es abdecken soll befindet.
Bei Texturen die sich wiederholen sollen (das GL_REPEAT) bedeutet das wiederum, dass die Coordinate 0.0 und auch 1.0 eine 50:50 Interpolation des 1. und des letzten Texels der Textur ist.

D.h:
Der X.te Wert deiner Textur die Y Texel groß ist, ist der Wert für die s-Koordinate: (X + 0.5) / Y

Beim linearen Interpolieren werden alle anderen Werte aus den 2 Nachbartexeln interpoliert, es sei denn du hast GL_CLAMP eingestellt und befindest dich im Bereich [-unendlich|0.5/Y] oder [(Y-0.5)/Y|+unendlich] dann gilt für diesen Bereich nur das eine Nachbartexel.

Obwohl es auf den ersten Blick etwas verwirrend ausschaut ist es bei näherer Betrachtung die beste Lösung, da damit jede Art der Texturierung (Wiederholung, Interpolationen, Tiles, ...) ohne allzu große Umstände ermöglicht wird.

Hoffe es war wenigstens halbwegs verständlich :-).

Denke das hab ich verstanden. (Irgendow hatte ich das vermutet) Wenn ich allerdings weiß wie groß meine Texel maximal sind, könnte ich ja genau den nötigen Spielraum von meinen Koordinaten abziehen um z.B. die Weisen Ränder zu vermeiden, oder?

Der artikel AL war auch sehr interessant.


Wenn du dich mit den Texelberechnungen gut auskennst, könntest du ja mal (deine Artikel sehn immer so doll aus, mit Bildern unds so ) den Artikel "Texelberechnung" schreiben. Der würde dem Technikpfad sicherlich gut tun.

_________________
Blog: kevin-fleischer.de und fbaingermany.com

Ich hatte das Problem auch mal, als ich ein paar Fenster im 2D Modus von OpenGL darstellen wollte.
Meine Texturen waren auch immer leicht unscharf...

Das ganze passiert aber nicht, wenn die OpenGL-Koordinaten in 2D absolut exakt die Pixel auf dem Bildschrim darstellen.
Auf sulaco gibt es ein Beispiel-Programm, welches ein paar Fenster darstellt. Dort werden die Fenster auch so exakt positioniert, dass die Filterung (die die Textur ja leicht unschärfer macht) zwar theoretisch gefiltert hat, im Endeffekt jedoch bekam man von der Filterung nichts mit, weil ja jeder Texel einen eigenen Pixel hatte. Und umgekehrt.

Aber dieser Artikel ist auch sehr interessant...

EDIT:
Und die Ränder von Texturen bekommt man oft mit GL_CLAMP bzw. GL_CLAMP_TO_EDGE weg.

_________________
"Für kein Tier wird so viel gearbeitet wie für die Katz'."