Textur Buffer oder andere Technik gesucht?

[sirnoname]

Hallo,

ich muss auf eine Textur pinseln, wie schon mal vorher erwähnt.
Dazu würde ich gerne die Textur aus einer Datei laden und dann beschreiben. Die Updates sind mit der Bildfrequenz von z.B. 60x pro Sekunde. Die Textur Vorlage sollte allerdings im Speicher bleiben um so schnell wieder neu bemahlt zu werden.

Welche Technik ist hier am besten / schnellsten:
- Bitmap laden, in Bitmap Text malen mit GDI DC, Bitmap in Textur laden, Textur darstellen
- Textur erstellen, Bitmap laden, Bitmap Inhalt im Speicher per memcpy ablegen, Text auf Bitmap mit GDI DC, Bitmap in Textur laden, Textur darstellen und dann wieder altes Bitmap holen mit memcpy
- Textur aus Datei laden, Textur mit memcpy im Speicher duplizieren, Textur mit Text bemalen, Textur darstellen und dann alte Textur holen und neu texten

Grüße,
SirNoName

[Blue Cobold]

Warum musst Du ständig auf die Textur pinseln? Doch hoffentlich nicht, weil Du noch mit dem Font-Zeug hantierst und jeden Frame einen neuen Text malen willst? Denn dafür würde ich an Deiner Stelle jedes Zeichen des Fonts einmal rendern und danach als Lookup-Tabelle/Sprite-Sheet auf der GPU belassen statt immer wieder von der CPU auf die GPU zu schieben und auch noch den Font immer neu zu rendern.
Mit mehr Info über Deinen Use-Case könnte man hier vermutlich eine bessere Lösung anbieten, als Deine aktuelle Idee.

[Stimpy]

Also so wie ich das lese geht es dir ja nicht um eine 3D API sondern um GDI z.B. oder andere Libs. Im Falle von GDI würde ich einmal ein neues GDI Bild im Speicher für den Text erzeugen in der breite und höhe die du ja vorher berechnen kannst. Dann nimmst du dieses kleine Bild im Speicher und gehst über das rectanglecopy oder wie das heißt und kopierst dies in das große Bild und speicherst dieses. Das kannst du auch nur dann machen wenn sich etwas aktualisiert hat am Bild, sonst schaffst du ein großen Overload.

Allerdings schließe ich mich meinem Vorredner an das man etwas genaueres sagen könnte wenn man wüsste was du erreichen willst.

[sirnoname]

Doch, eigentlich will ich den Font jeden Frame pinseln, da die Werte die ich pinsle in Echtzeit die aktuellen Werte anzeigen, also z.B. 60 mal pro Sekunde.
Das mit den vorgerenderten Fonts stelle ich mir schwierig vor, da der Untergrund der Textur nicht überschrieben werden darf, der Font muss also bis auf das Zeichen durchsichtig sein.
Ansonsten gebe ich dir recht, das sollte in der GPU passieren.
Gibt es dazu irgendwo Tutorials wie das auszusehen hat? Ich suche und suche aber finde nichts. Immer nur D3DXFont.

sonst schaffst du ein großen Overload

Ja, leider, allerdings brauche ich diese Updaterate der Werte.

[Blue Cobold]

Wie gesagt, zeichne den Font auf eine Textur, als Sprite-Sheet. Benutze dieses Sprite-Sheet dann zum Rendern des Textes. Hatte noch nie Probleme damit, mit Transparenz ebenfalls nicht. Und das ist mit Garantie schneller als jeden Frame das Bild auf der CPU zu rendern, auf die GPU zu schieben und dort nochmal zu rendern.
Ohnehin würde ich Dir empfehlen z.B. mit GIMP vorgerenderte Font-Sprite-Sheets zu verwenden, weil das allemal besser aussieht als auf der CPU gerenderte System-Fonts - solange man die Größe des Textes nicht ständig ändern will, dann ergeben sich mit dem Prerendering-Verfahren natürlich durch die Skalierung leichte Verwischungseffekte beim Rendern der Sprites.

[sirnoname]

Ein Sprite verwende ich nicht, muss eine Textur sein. Ein Renderschritt zwischen den beiden DX Objekten dürfte zusätzlichen Aufwand erzeugen.
Der sich ändernde Text ist auf Zahlen beschränkt und hat dieselbe Größe und denselben Zeichensatz.
Allerdings kann ich ohne reale Source Code Beispiele, irgendwelcher Tuts oder Game Engines, deinen Ausführungen nicht im Detail folgen. Ich nehme mal an man macht eine Textur mit Font quads und eine mit der eigentlichen Textur. Keine Ahnung welche Befehle zum Kopieren auf GPU Ebene hergenommen werden sollen. Bisher habe ich gesehen das man die Textur locked und dann mit memcpy arbeitet, das ist meiner Meinung nach allerdings CPU work. Davon abgesehen muss man eine weitere Textur mit dem ursprünglichen Inhalt als Buffer hernehmen.

hier ein Beispiel:

Code: Alles auswählen

void DevState::blit(unsigned int x, unsigned int y, unsigned int w, unsigned int h) {
	logme("D3D9: Blit %d %d %d %d", x, y, w, h);

	if (! texTexture || !a_ucTexture)
		return;

	D3DLOCKED_RECT lr;

	if ((x == 0) && (y == 0) && (w == uiWidth) && (h == uiHeight)) {
		if (texTexture->LockRect(0, &lr, NULL, D3DLOCK_DISCARD) != D3D_OK)
			return;
	} else {
		RECT r;

		r.left = x;
		r.top = y;
		r.right = x + w;
		r.bottom = y + h;

		if (texTexture->LockRect(0, &lr, &r, 0) != D3D_OK)
			return;
	}

	for (unsigned int r=0;r < h;++r) {
		unsigned char *dptr = reinterpret_cast<unsigned char *>(lr.pBits) + r * lr.Pitch;
		unsigned char *sptr = a_ucTexture + 4 * ((y + r) * uiWidth + x);
		memcpy(dptr, sptr, w * 4);
	}

	texTexture->UnlockRect(0);
}

[Schrompf]

Du verwendest ein Sprite, keine Sorge. Das Grundprinzip ist wirklich simpel:

1) Baue Dir ein Bild z.B. in einem Malprogramm, auf dem alle Buchstaben, Zahlen und Zeichen drauf sind, die Du brauchst.
2) Lege Dir dazu eine Tabelle im Code an, in der zu jedem Zeichen die Pixelkoordinaten der dazugehörigen Grafik auf dem Bild stehen.
3) Lade am Anfang des Programms das Bild in eine Textur.
4) Erstelle am Anfang des Programms einen dynamischen VertexBuffer mit Platz für ~4000 Vertizes.
4a) Erstelle evtl. dazu einen IndexBuffer, der jeweils 4 Vertizes zu einem Rechteck verbindet.

5) Im Programm tust Du jetzt, jedesmal wenn Du irgendwohin irgendwelchen Text zeichnen willst:
5a) Locke oder Mappe (je nach verwendeter 3D-API unterscheiden sich da die Begriffe) den VertexBuffer
5b) Fülle pro Zeichen, dass Du ausgeben willst, vier Vertizes hinzu, die ein Rechteck mit den Texturkoordinaten aus obiger Grafiktabelle beschreiben.
5c) Unlock() bzw. Unmap()
5c) Zeichne die Rechtecke.

Und schon hast Du einen Fontrenderer wie jeder andere auch. Das geht zugegebenermaßen noch etwas besser, aber da Du noch sehr am Anfang des Lernprozesses stehst, ist das erstmal genug.

[sirnoname]

Kein Sprite in DX11.
Ich versuch mich mal dort:
http://www.braynzarsoft.net/Articles/in ... DirectX-11

[Schrompf]

Du liest aber schon noch, was hier steht, oder? Ein texturiertes Rechteck ist ein Sprite. Nur halt nicht in der D3DXSprite-Implementation, sondern halt selbst geschrieben. Jetzt fang endlich an.

[TGGC]

Im DXSDK sind doch eigentlich immer eine Menge Beispiele fuer Textausgabe drin.

[sirnoname]

Danke, die SDK's verwenden DXUT, da hab ich schon mit den Static Menü Elementen geliebäugelt. Die DXUTGUI is allerdings non-dokumented und etwas komplex mit den DX9 Objekten im DX11 Code.

Bei dem obigen Prinzip stanze ich Zeichen aus und male sie an eine andere Position. Wie sieht es mit dem Hintergrund aus? Werden die Zeichen aufgerendert oder wird der Bereich ausgetauscht.
Wie auch immer ab Punkt 4 ist für mich ein Sample Code notwendig oder jemand hilft mir dabei den Code zu vervollständigen.

[Schrompf]

Wie erstellst Du denn bisher Deine VertexBuffer? Schau mal in der Doku zu der Funktion nach einem Flag D3D11_USAGE_DYNAMIC und Du hast den Teil erledigt.

Und wie renderst Du bisher Deine 3D-Grafik? Schau Dir mal Alpha Blending an, damit kombinierst Du die Grafik mit dem bisherigen Inhalt des Renderziels.

Code-Beispiele gibt es nicht, Du sollst ja was dabei lernen.

[sirnoname]

Ich bin da jetzt mit CopySubresourceRegion durch. Ganz einfach von FontTextur zu Textur.
Nun suche ich dasselbe für OpenGL. Leider kann ich da nur eine einzelne Textur wählen. Kopieren müsste über einen Buffer laufen was viel Resourcen frisst.
Gibt es in OpenGl einen Textur Kopier Befehl oder eine Routine?
Ja, dynamisch.

[Blue Cobold]

Wozu denn das? Das ist gar nicht notwendig. Du brauchst nichts von einer Textur auf eine andere zu kopieren. Du musst nur den Font auf ein Bild malen und dieses auf die GPU als Textur hochladen.

[Andre]

Wenn du nur Text in DirectX11 ausgeben möchtest wäre das hier vielleicht einen Blick wert: http://fw1.codeplex.com/

[sirnoname]

Ja, das habe ich auch gesehen, danke für den Tipp. Das was ich im Moment habe läuft lustigerweise sehr gut, da drehe ich im Moment nichts dran.