DrawIndexedPrimitive() schwerwiegendes Problem

[JensE]

Das Problem ist recht einfach formuliert:

Ich rendere ein Modell mit DrawIndexedPrimitive() und ich sehe nichts.
Dazu verwende ich einen VB und viele IBs (einer je Material). Sowohl die Indizes als auch die Stream Source und das FVF setze ich vor dem Rendern.
Keine dieser Funktionen schlägt fehl, auch DrawIndexedPrimitive() nicht. Dummerweise sehe ich nichts (keine Renderausgabe).

Wenn ich die Buffer locke und die Daten hole und das Ganze dann mit DrawIndexedPrimitiveUP() zeichne, is das Modell korrekt sichtbar!!!!

Was könnte das Problem sein?

[TGGC]

Woher zum Teufel soll ich das wissen?

Zu dumm, das die DX Debug Runtimes keinen Hinweis geben...

Bye, TGGC \-/

[rapso]

zeig mal wie du den buffer erstellst und lockst.

rapso->greets();

[JensE]

Hi,

den Code kann ich hier leider nich so einfach posten, jedenfalls schreibe ich die Index-Buffer nicht mit einem Mal voll. Alle Buffer werden mit D3DUSAGE_WRITEONLY erzeugt, da ich mit Hilfe einer Systemspeicher-Kopie auf die Daten zugreifen kann.

Ich bin mir sicher, dass die Daten in den Buffern absolut korrekt sind, da sie ja mit DrawIndexedPrimitiveUP() auch korrekt dargestellt werden, sie stimmen auch mit den Daten des gerenderten Modells überein, wenn ich sie mir in meine Protokoll-Datei ausgeben lass.

Grüße

Jens

[TGGC]

Dieses Problem wurde IMHO nicht ausreichend genau geschildert, um eine hilfreiche Antwort zu geben.
Fragen clever stellen

Dieses Posting wurde nicht automatisch generiert sondern per Hand eingefügt. Beschwerden werden trotzdem ignoriert.

Disclaimer: dies ist kein direkter persönlicher Angriff.

P.S.: Schöner Crosspost...

Bye, TGGC (Reden wie die Großen)

[JensE]

Mein Quellcode ist leider ganz schön verwinkelt, aber ich geb hier einfach mal paar Fetzen Code an:

Hier das Erzeugen, Updaten (Kopieren der Systemkopie in den Buffer) und Größe setzen für die Indexbuffer:

// :::::::::::::::::......... Erzeugungsfunktion
	// ....::: Erzeugt das Vertex-Buffer Objekt mit den übergebenen Parametern fürs Device pcDevice.
	// ....::: Dabei wird immer D3DUSAGE_WRITEONLY mit übergeben.

bool CVertexBuffer::Create(DWORD dwVertCount, DWORD dwVertSize, DWORD dwFVF, 
		LPDIRECT3DDEVICE8 pcDevice, DWORD dwUsage, D3DPOOL enPool)
{

	if (dwVertCount == 0 || dwVertSize == 0 || pcDevice == NULL)
		return false;

	dwUsage |= D3DUSAGE_WRITEONLY;

	if (FAILED(pcDevice->CreateVertexBuffer(dwVertCount * dwVertSize, dwUsage, dwFVF, enPool, 
		&this->m_pcVB)))
		if (dwUsage & D3DUSAGE_DYNAMIC)
			return this->Create(dwVertCount * dwVertSize, dwVertSize, dwFVF, pcDevice, 
				dwUsage ^ D3DUSAGE_DYNAMIC, enPool);

		else
			return false;

	this->m_dwSize = dwVertCount * dwVertSize;
	this->m_dwItemSize = dwVertSize;
	this->m_dwFVF = dwFVF;
	this->m_dwUsage = dwUsage;
	this->m_dwItemCount = dwVertCount;

	this->m_enPool = enPool;

	this->m_pbData = new BYTE[this->m_dwSize];

	return true;
}

	// :::::::::::::::::......... Aktualisieren
	// ....::: 

bool CVertexBuffer::Update(void)
{

	if (this->m_pcVB == NULL || this->m_pbData == NULL)
		return false;

	if (this->m_dwFirstItemIndex > m_dwLastItemIndex)
		return true;

	if (this->m_dwFirstItemIndex >= this->m_dwItemCount || m_dwLastItemIndex >= this->m_dwItemCount)
		return false;

	BYTE *pbVertices;		// Hier werden die gesperrten VB-Daten zur Verfügung gestellt

	DWORD dwCopyCount = (m_dwLastItemIndex - this->m_dwFirstItemIndex + 1) * this->m_dwItemSize;

	// Vertex-Buffer sperren: Sperrflag 0 bei statischem Vertex-Buffer und Sperrflag 
	// D3DLOCK_DISCARD bei dynamischen.
	if (FAILED(this->m_pcVB->Lock(this->m_dwFirstItemIndex * this->m_dwItemSize, dwCopyCount, 
		(BYTE**) &pbVertices, (m_dwUsage & D3DUSAGE_DYNAMIC) ? D3DLOCK_DISCARD : 0)))
		return false;
		// Vertexbuffer aktualisieren
	memcpy(pbVertices, &this->m_pbData[this->m_dwFirstItemIndex], dwCopyCount);

	this->m_pcVB->Unlock();

	this->m_dwFirstItemIndex = this->m_dwItemCount - 1;

	m_dwLastItemIndex = 0;

	return true;
}

	// :::::::::::::::::......... Größe verändern
	// ....::: Setzt eine neue Größe für den Vertex-Buffer, indem zuerst lokal ein neuer mit der
	// ....::: neuen Größer und den alten Eigenschaften erzeugt wird, danach der alte Inhalt in
	// ....::: den neuen reinkopiert und der alte freigegeben wird.

bool CVertexBuffer::SetSize(const DWORD dwNewVertCount, LPDIRECT3DDEVICE8 pcDevice)
{

	DWORD dwOldLast, dwOldFirst;

	LPDIRECT3DVERTEXBUFFER8 pcNewVB;

	if (dwNewVertCount == this->m_dwItemCount)
		return true;

	if (dwNewVertCount == 0 || pcDevice == NULL)
		return false;

	this->m_dwItemCount = dwNewVertCount;

	if (FAILED(pcDevice->CreateVertexBuffer(dwNewVertCount * this->m_dwItemSize, this->m_dwUsage, 
		this->m_dwFVF, this->m_enPool, &pcNewVB)))
		return false;

	this->m_pcVB->Release();

	this->m_pcVB = pcNewVB;

	BYTE *pbData;

	if (this->m_dwSize != 0)
	{
		pbData = new BYTE[this->m_dwSize];

		memcpy(pbData, this->m_pbData, this->m_dwSize);

		delete[] this->m_pbData;
	}

	this->m_pbData = new BYTE[dwNewVertCount * this->m_dwItemSize];

	if (this->m_dwSize != 0)
	{
		memcpy(this->m_pbData, pbData, this->m_dwSize);

		delete[] pbData;
	}

	dwOldFirst = this->m_dwFirstItemIndex;
	dwOldLast = m_dwLastItemIndex;
	this->m_dwFirstItemIndex = 0;
	m_dwLastItemIndex = this->m_dwItemCount - 1;

	if (!this->Update())
		return false;

	this->m_dwFirstItemIndex = dwOldFirst;
	m_dwLastItemIndex = dwOldLast;

	if (this->m_dwFirstItemIndex >= this->m_dwItemCount)
		this->m_dwFirstItemIndex = this->m_dwItemCount - 1;

	if (m_dwLastItemIndex >= this->m_dwItemCount)
		m_dwLastItemIndex = this->m_dwItemCount - 1;

	this->m_dwSize = dwNewVertCount * this->m_dwItemSize;

	return true;
}

Ganz analog sehen die entsprechenden Funktionen für den IB aus, so dass ich die hier nich mehr angebe.

In einer Ladefunktion rufe ich diese Methoden auf, und zwar so:

// Wenn noch keine Vertizes drin, VB erzeugen
	if (this->m_dwVertCount == 0)
		this->m_pcVB->Create(dwVertCount, sizeof(VERTEX), D3DFVF_VERTEX, pcDevice);
		// ansonsten erweitern
	else
		this->m_pcVB->SetSize(this->m_dwVertCount + dwVertCount, pcDevice);

	....
		// Vertex-Koos holen
	D3DVECTOR *pstVertPointer = (D3DVECTOR*) lDataPointer;

	for (DWORD h = 0; h < dwVertCount; h++)
	{
		pstVertices[h].fx = pstVertPointer[h].x;
		pstVertices[h].fy = pstVertPointer[h].y;
		pstVertices[h].fz = pstVertPointer[h].z;
	}

	....

		// Textur-Koos holen
	for (DWORD j = 0; j < dwCoords; j++)
	{
		pstVertices[j].ftu = pfCoords[2 * j];
		pstVertices[j].ftv = pfCoords[2 * j + 1];
	}

	....

	this->m_pcVB->SetItems(this->m_dwVertCount, dwVertCount, (BYTE*) pstVertices);

	this->m_pcVB->Update();	

	delete[] pstVertices;

	this->m_dwVertCount += dwVertCount;

	...

Wenn ihr unbedingt noch sehen wollt, wie die IBs gefüllt werden, kann ich das ja noch posten.
Aber wie gesagt, die Daten müssen 100% OK sein, ich hab sie wieder aus den Buffern gelesen und
mit den Meshdaten verglichen, außerdem wird er ja mit DrawIndexedPrimitiveUP() korrekt gerendert.

Das Problem ist: Mit DrawIndexedPrimitive() geht es nicht, es wird nichts gerendert/angezeigt/ist nichts sichtbar, und nochmal: Keine der DX-Funktionen schlägt fehl.

Hier der relevante Code der Render-Funktion:

if (FAILED(pcDevice->SetStreamSource(0, this->m_pcVB->GetVB(), sizeof(VERTEX))))
		fout << "FAILED VB" << endl;

	if (FAILED(pcDevice->SetVertexShader(D3DFVF_VERTEX)))
		fout << "FAILED VS" << endl;

	for (DWORD i = 0; i < this->m_pcMaterialRef->GetMaterialCount(); i++)
	{
		pcDevice->SetMaterial(this->m_pcMaterialRef->GetMatDesc(i));

		pcDevice->SetTexture(0, this->m_pcMaterialRef->GetTexture(i));

		pcDevice->SetIndices(this->m_pcMaterialRef->GetIB(i), 0);

		pcDevice->BeginScene();

		if (FAILED(pcDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, this->m_pcVB->GetItemCount(), 0, 
			this->m_pcMaterialRef->GetTriCount(i))))
			fout << "FAILED Draw" << endl;

		pcDevice->EndScene();
	}

Hoffe das reicht !