[D3DX9] Assimp - Materialien

[Oromis_32]

Hi @all,

ich bin gerade dabei, eine Modellklasse zu schreiben, die aus der (übersichtlichen und umfangreichen, Lob an die Programmierer!) Assimp - Bibliothek läd.

Dabei ist mir die Struktur aiMaterial über den Weg gelaufen. Ich nehme an, in dieser befinden sich Infos über die verwendeten Texturen.

Meine Fragen:
a) Wie bekomme ich den Texturpfad heraus?
b) Ist die Struktur noch für andere Dinge als Texturen da?

Danke im Voraus

Oromis

[klickverbot]

Zu a): An den Texturpfad kommst du am einfachsten mit aiMaterial::GetTexture. Du musst allerdings ein bisschen aufpassen, da die Texturen bei manchen Formaten auch direkt in die Modelldatei eingebettet sein können: http://assimp.sourceforge.net/lib_html/ ... l#textures.

Zu b): Ja, aiMaterial speichert neben den Texturen auch alle anderen Materialeigenschaften, die in der Modelldatei zu finden sind, also z.B. ob es sich um ein Wireframe-Material handelt, die Reflexionseigenschaften, etc…

[Oromis_32]

Danke für die Antwort!

a) Ich will einfach alle Texturen laden, die zu dem Modell gehören. Kann ich da für den Parameter "aiTextureType type" aiTextureType_NONE angeben, damit ich eine Textur beliebigen Typs bekomme?

b) wie komme ich an die Materialeigenschaften ran?
Reflexion, Streufarbe, ...

[Aramis]

Hallo und Herzlich Willkommen im Forum :-)

a) Nein, das geht leider nicht. Ich fuerchte du musst sie mit der aktuellen Version des APIs wirklich manuell abfragen, d.h. in einer Schleife ueber alle Texturtypen an denen du interessiert bist. Ich gebe zu, es ist etwas inflexibel.

b) mit aiMaterial::Get() und dem Key der gewuenschten Eigenschaft, z.b. AI_MATKEY_COLOR_DIFFUSE fuer die Streufarbe. Die Konstanten findest du im aiMaterial.h Header, oder (besser) au der Doku-Seite zum Materialsystem. Dort hat's auch Code-Beispiele.

Gruß, Alex

[Oromis_32]

OK, danke, das hat geholfen...

Jetzt habe ich die Testdatei jeep1.3ds geladen. Gerendert werden aber nur die Meshes 4 und 5 (die "Lenkränder" oder so), obwohl von allen 7 Meshes die Render - Funktion aufgerufen wird.

Alle Meshes haben sinnvolle Transformationsmatrizen, daran liegt es offensichtlich auch nicht...

Die Vertex - und Indexbuffer sind reichlich gefüllt (sind 47700 Vertizes und 14304 Indizes allein für Mesh 7 dieses Modells nicht ein wenig übertrieben?), also sollte er doch zumindest irgendwas rendern...

Hat jemand eine Idee?

[Aramis]

Hast du mal mit PIX nachgeguckt?

sind 47700 Vertizes und 14304 Indizes allein für Mesh 7 dieses Modells nicht ein wenig übertrieben?

jeep1.3ds? Das 7te Mesh hat 1192 Faces.

Der Grund, dass es genau 3x so viele Vertices wie Faces sind, ist Assimps Eigenschaft ohne PostProcessing-Flags voellig unindizierte Daten zurueckzugeben. Wenn du das aiProcess_JoinVertices-Flag angibst werden es deutlich weniger Vertices werden.

[Oromis_32]

Der Grund, dass es genau 3x so viele Vertices wie Faces sind, ist Assimps Eigenschaft ohne PostProcessing-Flags voellig unindizierte Daten zurueckzugeben. Wenn du das aiProcess_JoinVertices-Flag angibst werden es deutlich weniger Vertices werden.

Eigentlich habe ich aiProcess_JoinVertices durchaus angegeben...

Kann man irgendwie den Sourcecode des Assimp Viewers ansehen? Der ist ja auch mit DX geschireben und das würde extrem helfen...
Wäre eine super Sache, wenn du mir den irgendwie zukommen lassen könntest.

[Aramis]

Ja, auch er ist natuerlich verfuegbar. Aber ich kann ihn mittlerweile einfach nicht mehr als Referenz empfehlen, der Source-Code ist graesslich dahingehackt und danach hundertfach geflickt.

http://assimp.svn.sourceforge.net/viewv ... simp_view/


Du koenntest uns aber auch mal deinen Code zeigen, vll. kann man da den Fehler finden.

[Oromis_32]

OK, hier ist mein Code. Ich habe die Klasse CMeshModel getauft, obwohl ich mir im klaren bin, dass im Assimp - Sinn Meshes nur ein kleiner Teil des Modells sind.

Alle Objekte und Funktionen, die das Präfix "tb" haben, sind Teile der Engine die ich benutze.

Mesh.h

Code: Alles auswählen

class CMeshModel;

struct SMaterial
{
	list<string> asTextureNames;
	D3DMATERIAL9 Material;
};

/*
* Ein "Teilmesh"
*/
class CMesh
{
public:
	CMesh();
	~CMesh();

	tbResult Init(aiMesh* pMesh, CMeshModel* pModel);
	tbResult Exit();

	tbResult Render();

private:
	tbVertexBuffer*		m_pVB;
	tbIndexBuffer*		m_pIB;

	int					m_iMaterialIndex;

	CMeshModel*			m_pModel;
};

/*
* Ein Knoten in der Mesh - Struktur
*/
class CMeshNode
{
public:
	CMeshNode();
	~CMeshNode() { Exit(); }

	tbResult	Init(aiNode* pNode, CMeshModel* pModel);
	tbResult	Exit();

	tbResult	Render();

	string		GetName()	{ return m_sName; }

protected:
	list<int>			m_aiMeshes;
	list<CMeshNode*>	m_apChilds;

	string				m_sName;
	tbMatrix			m_mTransformation;

	CMeshModel*			m_pModel;
};

/*
* Das eigentliche Modell
*/
class CMeshModel
{
public:
	CMeshModel();
	~CMeshModel() { Exit(); }

	tbResult	Init(const aiScene* pModel);
	tbResult	Exit();

	tbResult	Render();

	CMesh**		GetMeshes()		{ return m_apMeshes; }
	SMaterial*	GetMaterial(int iIndex) { return m_apMaterials[iIndex]; }

protected:
	CMeshNode*	m_pRoot;

	int			m_iMeshCount;
	CMesh**		m_apMeshes;

	int			m_iMaterialCount;
	SMaterial**	m_apMaterials;
};

Mesh.cpp

Code: Alles auswählen

struct SMeshVertex
{
	tbVector3			vPosition;	// Position des Vertex
	tbVector3			vNormal;	// Normalenvektor
	DWORD				dwColor;	// Farbe des Vertex
	tbVector2			vTexture;	// Texturkoordinaten
	static const DWORD	dwFVF;		// Vertexformat
};

const DWORD SMeshVertex::dwFVF = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 | D3DFVF_DIFFUSE;

CMesh::CMesh()
{
	m_pVB = new tbVertexBuffer();
	m_pIB = new tbIndexBuffer();
}

CMesh::~CMesh()
{
	Exit();
	Del(m_pVB);
	Del(m_pIB);
}

tbResult CMesh::Init(aiMesh* pMesh, CMeshModel* pModel)
{
	if(!pMesh->HasFaces()) TB_ERROR("Fehler: Mesh hat keine Indizes", TB_ERROR);

	m_pVB->Init(pMesh->mNumVertices * sizeof(SMeshVertex), sizeof(SMeshVertex), SMeshVertex::dwFVF);

	for(int i = 0; i < pMesh->mNumVertices; i++)
	{
		SMeshVertex Vertex;
		Vertex.vPosition = tbVector3(pMesh->mVertices[i].x, pMesh->mVertices[i].y, pMesh->mVertices[i].z);
		if(pMesh->HasNormals())
		{
			Vertex.vNormal = tbVector3(pMesh->mNormals[i].x, pMesh->mNormals[i].y, pMesh->mNormals[i].z);;
		}
		else
		{
			TB_WARNING("VERTEX ohne Normalen");
		}

		if(pMesh->HasTextureCoords(0))
		{
			Vertex.vTexture = tbVector2(pMesh->mTextureCoords[0][i].x, pMesh->mTextureCoords[0][i].y);
		}
		else
		{
			TB_WARNING("VERTEX ohne Texture Coords");
		}

		if(pMesh->HasVertexColors(0))
		{
			Vertex.dwColor = tbColor(pMesh->mColors[0][i].r, pMesh->mColors[0][i].g, pMesh->mColors[0][i].b, pMesh->mColors[0][i].a);
		}
		else
		{
			Vertex.dwColor = tbColor(0.0f, 0.0f, 1.0f);	// Testweise blau
		}

		m_pVB->AddVertex(&Vertex);
	}
	m_pVB->Update();

	m_pIB->Init(pMesh->mNumFaces * 3 * 4, 4, D3DFMT_INDEX32);
	for(int i = 0; i < pMesh->mNumFaces; i++)
	{
		aiFace& Face = pMesh->mFaces[i];
		if(Face.mNumIndices != 3) TB_WARNING("Face hat nicht 3 Indizes");
		m_pIB->AddIndex(&Face.mIndices[0]);
		m_pIB->AddIndex(&Face.mIndices[1]);
		m_pIB->AddIndex(&Face.mIndices[2]);
	}
	m_pIB->Update();

	m_iMaterialIndex = pMesh->mMaterialIndex;
	m_pModel = pModel;

	//tbWriteToLog("Initialisiere Mesh");

	return TB_OK;
}

tbResult CMesh::Exit()
{
	if(m_pVB) m_pVB->Exit();
	if(m_pIB) m_pIB->Exit();

	return TB_OK;
}

tbResult CMesh::Render()
{
	tbDirect3D& D3D = tbDirect3D::Instance();

	tbWriteToLog("Render Mesh - VertexCount: %i, IndexCount: %i", m_pVB->GetSize(), m_pIB->GetSize());
	tbWriteMatrixToLog(D3D.GetTransform(D3DTS_WORLD));

	DWORD dwOldFVF = D3D.GetFVF();

	// Vertexformat sowie Vertex- und Index-Buffer setzen
	D3D.SetFVF(m_pVB->GetFVF());
	D3D->SetStreamSource(0, m_pVB->GetVB(), 0, m_pVB->GetVertexSize());
	D3D->SetIndices(m_pIB->GetIB());

	string sTextureName = (*m_pModel->GetMaterial(m_iMaterialIndex)->asTextureNames.begin());
	sTextureName = "Data\\" + sTextureName;
	
	PDIRECT3DTEXTURE9 pTexture = tbTextureManager::Instance().GetTexture((char*) sTextureName.c_str());
	if(!pTexture) TB_ERROR("Textur ungültig", TB_ERROR);
	D3D->SetTexture(0, pTexture);

	D3D->SetMaterial(&m_pModel->GetMaterial(m_iMaterialIndex)->Material);

	// Rendern - Ist Trianglestrip als Typ korrekt?
	HRESULT hResult = D3D->DrawIndexedPrimitive(D3DPT_TRIANGLESTRIP,
													0,
													0,
													m_pIB->GetSize(),
													0,
													m_pIB->GetSize() / 2 - 1);
	if(FAILED(hResult))
	{
		// Fehler beim Rendern!
		TB_ERROR("Fehler bei D3D->DrawIndexedPrimitive", TB_ERROR);
	}

	D3D.Capture();

	return TB_OK;
}

CMeshNode::CMeshNode()
{
	
}

tbResult CMeshNode::Init(aiNode *pNode, CMeshModel* pModel)
{
	for(int i = 0; i < pNode->mNumMeshes; i++)
	{
		m_aiMeshes.push_back(pNode->mMeshes[i]);
	}

	for(int i = 0; i < pNode->mNumChildren; i++)
	{
		CMeshNode* pChild = new CMeshNode();
		if(pChild->Init(pNode->mChildren[i], pModel))
		{
			TB_ERROR("Fehler beim Initialisieren eines Knotens", TB_ERROR);
		}
		m_apChilds.push_back(pChild);
	}

	m_sName = pNode->mName.data;
	m_mTransformation = tbMatrix(
		pNode->mTransformation.a1, 
		pNode->mTransformation.a2, 
		pNode->mTransformation.a3, 
		pNode->mTransformation.a4, 
		pNode->mTransformation.b1, 
		pNode->mTransformation.b2, 
		pNode->mTransformation.b3, 
		pNode->mTransformation.b4,
		pNode->mTransformation.c1, 
		pNode->mTransformation.c2, 
		pNode->mTransformation.c3, 
		pNode->mTransformation.c4,
		pNode->mTransformation.d1, 
		pNode->mTransformation.d2, 
		pNode->mTransformation.d3, 
		pNode->mTransformation.d4);

	m_pModel = pModel;

	return TB_OK;
}

tbResult CMeshNode::Exit()
{
	m_aiMeshes.clear();

	for(list<CMeshNode*>::iterator it = m_apChilds.begin(); it != m_apChilds.end(); it++)
	{
		Del(*it);
	}
	m_apChilds.clear();

	return TB_OK;
}

tbResult CMeshNode::Render()
{
	tbMatrix mTransform = tbDirect3D::Instance().GetTransform(D3DTS_WORLD) * m_mTransformation;
	tbDirect3D::Instance().SetTransform(D3DTS_WORLD, mTransform);
	for(list<int>::iterator it = m_aiMeshes.begin(); it != m_aiMeshes.end(); it++)
	{
		if(m_pModel->GetMeshes()[(*it)]->Render()) TB_ERROR("Fehler beim Rendern eines Meshes", TB_ERROR);
	}

	for(list<CMeshNode*>::iterator it = m_apChilds.begin(); it != m_apChilds.end(); it++)
	{
		if((*it)->Render()) TB_ERROR("Fehler beim Rendern eines MeshNodes", TB_ERROR);
		tbDirect3D::Instance().SetTransform(D3DTS_WORLD, mTransform);
	}

	return TB_OK;
}

CMeshModel::CMeshModel()
{
	m_pRoot = new CMeshNode();
}

tbResult CMeshModel::Init(const aiScene* pModel)
{
	m_iMeshCount = pModel->mNumMeshes;
	m_apMeshes = new CMesh*[m_iMeshCount];
	for(int i = 0; i < m_iMeshCount; i++)
	{
		CMesh* pMesh = new CMesh();
		if(pMesh->Init(pModel->mMeshes[i], this))
		{
			TB_ERROR("Fehler beim Laden eines Meshes", TB_ERROR);
		}
		m_apMeshes[i] = pMesh;
	}

	m_iMaterialCount = pModel->mNumMaterials;
	m_apMaterials = new SMaterial*[m_iMaterialCount];
	for(int i = 0; i < m_iMaterialCount; i++)
	{
		m_apMaterials[i] = new SMaterial();

		aiTextureType aiTexTypes[] = { aiTextureType_DIFFUSE, aiTextureType_SPECULAR ,aiTextureType_AMBIENT ,aiTextureType_EMISSIVE };

		for(int k = 0; k < 4; k++)
		{
			for(int j = 0; j < pModel->mMaterials[i]->GetTextureCount(aiTexTypes[k]); j++)
			{
				aiString sPath;
				pModel->mMaterials[i]->GetTexture(aiTexTypes[k], j, &sPath);
				m_apMaterials[i]->asTextureNames.push_back(sPath.data);
			}
		}

		aiColor3D color(0.f, 0.f, 0.f); 
		pModel->mMaterials[i]->Get(AI_MATKEY_COLOR_DIFFUSE, color);
		m_apMaterials[i]->Material.Diffuse = tbColor(color.r, color.b, color.g);

		color.r = 0.f;	color.b = 0.f;	color.g = 0.f;
		pModel->mMaterials[i]->Get(AI_MATKEY_COLOR_AMBIENT, color);
		m_apMaterials[i]->Material.Ambient = tbColor(color.r, color.b, color.g);

		color.r = 0.f;	color.b = 0.f;	color.g = 0.f;
		pModel->mMaterials[i]->Get(AI_MATKEY_COLOR_EMISSIVE, color);
		m_apMaterials[i]->Material.Emissive = tbColor(color.r, color.b, color.g);

		color.r = 0.f;	color.b = 0.f;	color.g = 0.f;
		pModel->mMaterials[i]->Get(AI_MATKEY_COLOR_SPECULAR, color);
		m_apMaterials[i]->Material.Specular = tbColor(color.r, color.b, color.g);

		float fPower = 0.f;
		pModel->mMaterials[i]->Get(AI_MATKEY_SHININESS, fPower);
		m_apMaterials[i]->Material.Power = fPower;
	}

	return m_pRoot->Init(pModel->mRootNode, this);
}

tbResult CMeshModel::Exit()
{
	for(int i = 0; i < m_iMeshCount; i++)
	{
		Del(m_apMeshes[i]);
	}
	DelArray(m_apMeshes);

	for(int i = 0; i < m_iMaterialCount; i++)
	{
		Del(m_apMaterials[i]);
	}
	DelArray(m_apMaterials);

	return m_pRoot->Exit();
}

tbResult CMeshModel::Render()
{
	TB_INFO("RENDER START<br>----------------------------------------");
	return m_pRoot->Render();
}

[Aramis]

Es muesste eine D3DPT_TRIANGLELIST sein, probier das bitte mal bevor wir weitersehen.
tb - das ist die TriBase-Engine von David Scherfgen aus einem seiner Buecher? Das API kommt mir grob bekannt vor.

[Oromis_32]

Korrekt: TriBase - Engine. Ich war bisher zu faul, mir andere Engines anzuschauen und die finde ich recht einfach zu benutzen. Ich fahre ganz gut damit.

Ich habe schon öfters zwischen Trinaglelist und -strip hin und her gewechselt, kein großer Unterschied auszumachen.

[Oromis_32]

Gibt es denn keine Andere Stell, an der der Code hakt?
Bitte, helft mir!

[Aramis]

Nachtrag:

sind 47700 Vertizes und 14304 Indizes allein für Mesh 7 dieses Modells nicht ein wenig übertrieben?

jeep1.3ds? Das 7te Mesh hat 1192 Faces.

Faktor 12, ich vermute mal du hast ausversehen die Groesse des Indexbuffers in Bytes genommen.

Ich habe schon öfters zwischen Trinaglelist und -strip hin und her gewechselt, kein großer Unterschied auszumachen.

Es kann nur mit TriangleList funktionieren. Assimp liefert keine Strips, und du generierst sie auch nicht beim Konvertieren.

Code: Alles auswählen

m_pIB->GetSize() / 2 - 1

… der letzte DrawIndPr-Parameter ist afaik die Zahl der Primitiven - also m_pIB->GetSize()/3 fuer eine TriangleList. /12 wenn GetSize() die Groesse in Bytes zurueckgibt! (Merkwuerdige Aehnlichkeit mit obigem Nachtrag :-) )

Hast du mal die DirectX Debug-Runtime aktiviert und nach Fehlermeldungen geguckt? Mal PIX gestartet und nachgeguckt was wirklich gerendert wird? Der Quellcode sieht sonst fuer mich in Ordnung aus, zumindest was die Verwendung von Assimp angeht.

Gruß, Alex

[Oromis_32]

Der Hinweis auf den Bytes - mit - Vertizes - Verwechselt - Bug hat dazu geführt, dass mehr gerendert wird.... Ich habe einen Screen angehängt. Der rot umrandete Bereich vor dem Hintergrund der Wüstenlandschaften der Erde ist die aktuelle Interpretation des Jeeps... ;) Noch verbesserungswürdig...

Vllt habe ich noch einen ähnlichen Fehler drin, ich schaue gleich den Code zum 10101. mal an.

Der DX - Debugger sagt nichts erwähnenswertes. Und, öhhhhm, wahrscheinlich peinlich, aber was ist PIX?

[Aramis]

Du findest ihn im DX SDK - in irgendeinem /tools Verzeichnis, afaik hat es aber auch im Startmenue eine Verknuepfung. PIX zeichnet all deine D3D-Aufrufe komplett auf und erlaubt dir nachzuvollziehen was zu einem bestimmten Zeitpunkt der genaue Device-Status ist (u.a. kannst du dir den Inhalt deiner VBs grafisch anzeigen lassen, wenn dabei nur Schrott zu sehen ist hast du ihn entweder falsch befuellt oder die Vertexdeklaration ist falsch). Ein enorm nuetzliches Tool, nicht nur um Assimp-Modell-Renderer zu debuggen :-)

[Oromis_32]

WTF?!?!?

Ich habe gerade zwecks eines Tests des Spiels im LAN - Modus das Programm auf meinem Notebook laufen lassen. Das hat eine Intel - Onboard - Karte (!!). Auf diesem ist das Modell fehlerfrei gerendert, zumindest, wenn man von den völlig falschen Texturkoordinaten und dem inversen Cullmode absieht. Nachdem ich den Cullmode auf CW umgestellt hatte, kann man den Jeep ohne weiteres erkennen!

Jetzt stellt sich mir die Frage, warum meine HD 4870 nicht hinbringt, was mein Notebook (nach elendig langer Ladezeit ;) ) zustande bringt.

[Aramis]

PIX! Und die D3D-Debug Runtime. Kommen sicher haufenweise Fehlermeldungen :-)

[Oromis_32]

Nicht wirklich. Wie ich bereits gepostet hatte, gibt die D3D runtime keine Fehler aus, lediglich Warnungen, die nichts damit zu tun haben.

Was PIX angeht.... Ich kann damit zwar alle Aufrufe an DX - Funktionen nachvollziehen, aber keine VBs einsehen :-/

[Oromis_32]

OK, ich habe es jetzt, nach anderthalb Monaten herausgefunden. Der Fehler war lächerlich...

statt

Code: Alles auswählen

HRESULT hResult = D3D->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,
													0,
													0,
													m_pIB->GetSize() / sizeof(SMeshVertex),
													0,
													m_pIB->GetSize() / (3 * sizeof(float)));

muss es

Code: Alles auswählen

HRESULT hResult = D3D->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,
													0,
													0,
													m_pIB->GetSize() / sizeof(float),
													0,
													m_pIB->GetSize() / (3 * sizeof(float)));

heißen.

Jetzt ging es schon ganz schön voran, aber eine Frage hätte ich noch:

Die Meisten Modelle bestehen ja aus mehreren Teil-Meshes. Jeder Teil-Mesh hat auch eine Matrix, die die relative Position, Skalierung und Drehung zum vorhergehenden Mesh speichert.
Jetzt wüsste ich gern, wie ich diese Matrizen verrechne - also z.B. die aktuelle Weltmatrix mit der Matrix des Top-Level-Meshes.

Matrixmultiplikation habe ich ausprobiert, hat aber wie erwartet nicht funktioniert ;)