✔ [DirectX] Wahl von Indexbuffer

[Cromon]

Hallo zusammen!

Ich stehe wieder an einem Punkt an welchem ich vor einiger Zeit schon war. Ich habe eine Masse an Vertices und weiss nicht, wie ich diese geschickt in einen Indexbuffer packe. Genau genommen handelt es sich sogar wieder um die genau gleiche Masse mit der genau gleichen Aufteilung wie das letzte Mal. Einen Unterschied gibt es hier allerdings. Ich verwende nicht mehr OpenGL, sondern ich verwende DirectX. Ausserdem habe ich diesemal nicht eine Anwendung in der ich notfalls abgucken könnte sondern bin darauf angewiesen alles selber zu machen.

Nun, die Ausgangssituation ist einfach: Ich habe Quadrate bestehend aus 145 Punkten und ich möchte die Dreiecke darin möglichst performant rendern. Mein Problem: Ich bin unkreativ und komme auf keinen Weg, ausserdem bin ich noch nicht so geübt im Umgang mit der ganzen Sache. Ich würde mich daher freuen, wenn mir jemand möglichst detailliert (am besten davon ausgehen, ich hätte überhaupt keine Ahnung) einen Weg weisen könnte.

Anbei natürlich auch noch ein Screenshot wie das aussieht, was ich meine:
http://www.imagr.eu/up/4aeccfeef0774_Agy.JPG

Die verschiedenen Farben grenzen diese 145-Punkte-Quadrate ab.

Gruss
Cromon

 

[Matthias Reitinger]

Ich stehe wieder an einem Punkt an welchem ich vor einiger Zeit schon war. Ich habe eine Masse an Vertices und weiss nicht, wie ich diese geschickt in einen Indexbuffer packe. Genau genommen handelt es sich sogar wieder um die genau gleiche Masse mit der genau gleichen Aufteilung wie das letzte Mal.

Ich nehme an, du beziehst dich auf dieses Thema? http://www.tutorials.de/forum/c-c/346300-opengl-flaeche-von-vertices-rendern.html

Einen Unterschied gibt es hier allerdings. Ich verwende nicht mehr OpenGL, sondern ich verwende DirectX. Ausserdem habe ich diesemal nicht eine Anwendung in der ich notfalls abgucken könnte sondern bin darauf angewiesen alles selber zu machen.

Und welches Feature von OpenGL fehlt dir jetzt bei DirectX? Woran scheitert die Portierung?

Grüße,
Matthias

 

[Cromon]

Ja, genau das Thema meinte ich. Ein Bekannter zeigte mir eine Applikation, welche das selbe tat und ich hatte das übernommen. Wo das Problem liegt? Relativ einfach: Da ich den Weg, den "ich" in OpenGL genommen habe nicht verstehe kann ich ihn nur schlecht portieren. Daher würde ich jetzt gerne alles nochmals neu machen und dann auch verstehen. Das Vorhandene zu portieren habe ich heute schon vergeblich versucht.

Gruß
Cromon

 

[Matthias Reitinger]

Ja, genau das Thema meinte ich. Ein Bekannter zeigte mir eine Applikation, welche das selbe tat und ich hatte das übernommen. Wo das Problem liegt? Relativ einfach: Da ich den Weg, den "ich" in OpenGL genommen habe nicht verstehe kann ich ihn nur schlecht portieren. Daher würde ich jetzt gerne alles nochmals neu machen und dann auch verstehen. Das Vorhandene zu portieren habe ich heute schon vergeblich versucht.

Warum zeigst du uns dann nicht einfach die OpenGL-Lösung? Warum sollten wir für dich das Rad neu erfinden

Grüße,
Matthias

 

[Cromon]

Das kann ich morgen gerne tun, jetzt bin ich gerade am iPhone und habe den Code nicht.

Vielleicht würde man ja ein bessseres Rad erfinden

Gruss
Cromin

 

[Cromon]

So, hier nun der entsprechende Code, der in OpenGL funktioniert hat und von dem ich ehrlich gesagt kaum eine Zeile verstehe, nicht im Sinne des Programmiertechnischen, sondern was die Intention dahinter war:

	g_strip = new ui16[256];
	ui16* s = g_strip;
	bool first = true;
	for (int y = 0; y < 4; y++) 
	{
		for (int x = 0; x < 4; x++) 
		{
			int i = x * 2;
			int j = y * 4;
			for (int k = 0; k < 2; k++) 
			{
					if (!first) 
						*s++ = indexMapBuf(i, j + k * 2);
					else 
						first = false;
					for (int l = 0; l < 3; l++) 
					{
						*s++ = indexMapBuf(i + l, j + k * 2);
						*s++ = indexMapBuf(i + l, j + k * 2 + 2);
					}
					*s++ = indexMapBuf(i + 2, j + k * 2 + 2);
			}
		}
	}
	g_striplen = (int)(s - g_strip);

Und der Funktion indexMapBuf

int indexMapBuf(int x, int y)
{
	return ((y + 1) / 2) * 9 + (y / 2) * 8 + x;
}

Und gezeichnet wurde das dann mit:

glDrawElements(GL_TRIANGLE_STRIP, g_striplen, GL_UNSIGNED_SHORT, g_strip);

Was ich mir nun überlegt habe war folgendes:

	Tile::m_striplen = (int)(s - strip);
	Tile::m_indices = pMgr->CreateIndexBuffer(strip, m_striplen);

Und dann entsprechend beim Zeichnen:

m_3dMgr->DrawPrimitives(m_vbuffer, D3DPT_TRIANGLESTRIP, m_striplen / 3, VERTEX_3F, m_indices, 145);

Wobei DrawPrimitives folgendermassen aussieht:

void D3DManager::DrawPrimitives(IDirect3DVertexBuffer9* pBuffer, D3DPRIMITIVETYPE type, ui32 nPrims, FVF fvf, IDirect3DIndexBuffer9* pIndices, ui32 nVertices)
{
	if(!m_device)
		return;
	m_device->SetFVF((DWORD)fvf);
	switch(fvf)
	{
	case VERTEX_3F:
		{
			m_device->SetStreamSource(0, pBuffer, 0, sizeof(Vertex3F));
			break;
		}
	case VERTEX_3FC:
		{
			m_device->SetStreamSource(0, pBuffer, 0, sizeof(Vertex3FC));
			break;
		}
	}

	if(!pIndices)
	{
		HRESULT hr = m_device->DrawPrimitive(type, 0, nPrims);
		if(FAILED(hr))
			printf("\t%u\n", HRESULT_CODE(hr));
	}
	else
	{
		m_device->SetIndices(pIndices);
		HRESULT hr = m_device->DrawIndexedPrimitive(type, 0, 0, nVertices, 0, nPrims);
		if(FAILED(hr))
			printf("%u\n", HRESULT_CODE(hr));
		m_device->SetIndices(0);
	}
	m_device->SetStreamSource(0, 0, 0, 0);
}

Das hat leider nicht funktioniert. Fehler gibts keine, aber gezeichnet wird nichts.

/edit:
Ich habe irgendwas geändert und jetzt gehts plötzlich. Ich glaube ich hatte ein Durcheinander mit den Vertices und dem Vertexformat. Also dass ich einen Vertexbuffer mit einem anderen Vertexformat gemacht habe als dann beim Zeichnen. Ausserdem habe ich von m_striplen /3 auf m_striplen geändert und das Culling deaktiviert (bin mir von OpenGL gewohnt, dass das standardmässig deaktiviert ist) und jetzt funktioniert es!

Gruss
Cromon