Problem beim Laden von Modellen

[mortl]

Hallo,

Ich bastle zur Zeit an einem Modellformat für meine Engine. Das Konvertieren funktioniert recht gut, nur das Einlesen der Modelldaten oft nicht.
Wenn ich Modelle mit wenig Vertizes nehme(z.B Würfel), funktioniert es, aber wenn es größere Modelle sind dann nicht. Hier mal etwas Code:
Das ist ein Teil der Konvertierungsfunktion:

//Der Vertex Chunk wird geschrieben
	/***************************************************/

	VertexHeader.dwFVF = Mesh->GetFVF();
	VertexHeader.dwNumFaces = Mesh->GetNumFaces();
	VertexHeader.dwNumVertizes = Mesh->GetNumVertices();

	ChunkHeader.dwType = CT_VERTIZES;
	ChunkHeader.dwSize = sizeof(VertexHeader) + 
		                 D3DXGetFVFVertexSize(Mesh->GetFVF()) * VertexHeader.dwNumVertizes;

	fwrite(&ChunkHeader, sizeof(ChunkHeader), 1, pFile);	

	fwrite(&VertexHeader, sizeof(VertexHeader), 1, pFile);

	LPVOID VertexBufferStart;

	Mesh->LockVertexBuffer(D3DLOCK_DISCARD, &VertexBufferStart);

	fwrite(VertexBufferStart, D3DXGetFVFVertexSize(VertexHeader.dwFVF), VertexHeader.dwNumVertizes, pFile);

	Mesh->UnlockVertexBuffer();

	//Der Index Chunk wird geschrieben
	/***************************************************/

	IndexHeader.dwIndexSize = sizeof(WORD);
	IndexHeader.dwNumIndizes = VertexHeader.dwNumFaces * 3;

	ChunkHeader.dwType = CT_INDIZES;
	ChunkHeader.dwSize = sizeof(IndexHeader) +
		                 sizeof(WORD) * IndexHeader.dwNumIndizes;

	fwrite(&ChunkHeader, sizeof(ChunkHeader), 1, pFile);

	fwrite(&IndexHeader, sizeof(IndexHeader), 1, pFile);

	LPVOID IndexBufferStart;
	Mesh->LockIndexBuffer(D3DLOCK_DISCARD, &IndexBufferStart);

	fwrite(IndexBufferStart, IndexHeader.dwIndexSize, IndexHeader.dwNumIndizes, pFile);

	Mesh->UnlockIndexBuffer();

	//Der Material Chunk wird geschrieben
	/****************************************************/

	Material = (D3DXMATERIAL*)lpD3DXBuffer->GetBufferPointer();

	ChunkHeader.dwType = CT_MATERIAL;
	ChunkHeader.dwSize = sizeof(Material->MatD3D);

	fwrite(&ChunkHeader, sizeof(ChunkHeader), 1, pFile);

	fwrite(&Material->MatD3D, sizeof(Material->MatD3D), 1, pFile);

	//Der Textur Chunk...
	/*****************************************************/

	ChunkHeader.dwType = CT_TEXTURE;
	ChunkHeader.dwSize = sizeof(Material->pTextureFilename);

	fwrite(&ChunkHeader, sizeof(ChunkHeader), 1, pFile);

	fprintf(pFile, "%s", Material->pTextureFilename);

Und hier ein Teil der Ladefunktion

for(int i = 0; i < 4; i++) 
	{
		//Der Chunk Header wird eingelesen
		fread(&ChunkHeader, sizeof(sChunkHeader), 1, pFile);

		switch(ChunkHeader.dwType)
		{
			default:
				//Wenn der Chunk unbekannt ist wird er übersprungen
				fseek(pFile, ChunkHeader.dwSize, SEEK_SET);
				break;

			//Falls es der Vertex Chunk ist...
			case CT_VERTIZES:			

				//...wird der Vertex Header eingelesen...
				fread(&VertexHeader, sizeof(sVertexHeader), 1, pFile);

				//...und der VertexBuffer erzeugt
				m_pD3D->GetDevice()->CreateVertexBuffer(D3DXGetFVFVertexSize(VertexHeader.dwFVF) * VertexHeader.dwNumVertizes,
					                                 D3DUSAGE_WRITEONLY,
													 VertexHeader.dwFVF,
													 D3DPOOL_MANAGED,
													 &VertexBuffer,
													 NULL);

				LPVOID VertexBufferStart;
				VertexBuffer->Lock(0, 0, &VertexBufferStart, D3DLOCK_DISCARD);

				//Anschließend werden die Daten aus der Datei gelesen und in den Buffer kopiert
				fread(VertexBufferStart,D3DXGetFVFVertexSize(VertexHeader.dwFVF), VertexHeader.dwNumVertizes, pFile);// D3DXGetFVFVertexSize(VertexHeader.dwFVF), VertexHeader.dwNumVertizes, pFile);

				VertexBuffer->Unlock();

				break;

			//Falls es der Index Chunk ist...
			case CT_INDIZES:				

				//...wird der Index Header eingelesen...
				fread(&IndexHeader, sizeof(sIndexHeader), 1, pFile);

				//...und der IndexBuffer erzeugt
				m_pD3D->GetDevice()->CreateIndexBuffer(IndexHeader.dwIndexSize * IndexHeader.dwNumIndizes,
					                                D3DUSAGE_WRITEONLY,
													D3DFMT_INDEX16,
													D3DPOOL_MANAGED,
													&IndexBuffer,
													NULL);

				LPVOID IndexBufferStart;
				IndexBuffer->Lock(0,0, &IndexBufferStart, D3DLOCK_DISCARD);

				//Anschließend werden die Daten aus der Datei gelesen und in den Buffer kopiert
				fread(IndexBufferStart, IndexHeader.dwIndexSize, IndexHeader.dwNumIndizes, pFile);

				IndexBuffer->Unlock();

				break;

			//Falls es der Material Chunk ist...
			case CT_MATERIAL:		

				Material = new D3DXMATERIAL;

				//...werden die Materialdaten aus der Datei gelesen
				fread(&Material->MatD3D, sizeof(Material->MatD3D), 1, pFile);				

				break;		

			//Und wenn dann noch ein Textur Chunk auftaucht...				
			case CT_TEXTURE:

				LPSTR Filename = new char[255];

				//Wird, wer häts gedacht, der Name der Textur eingelesen...
				fscanf(pFile, "%s", Filename);

				if(!Filename)
					return;

				//...und anschließend erzeugt
				D3DXCreateTextureFromFile(m_pD3D->GetDevice(), Filename, &Texture);			
		}
	}

Ich hoffe der Thread ist nicht zu groß und jemand kann mir weiterhelfen

Mortl

[adapto]

was hast du den für fehler? oder was funktioniert nicht richtig?

[TGGC]

Ich hoffe der Thread ist nicht zu groß und jemand kann mir weiterhelfen

Noch viel Glück!

Bye, TGGC \-/

[mortl]

Das Problem liegt beim Einlesen der Daten.
Ich hab schon mal alles durch den Debugger laufen lassen und beim Einlesen gib
"fread" einen niedrigeren Wert zurück als "fwrite" beim schreiben, liest also weniger Daten ein als es soll, was mir aber völlig unverständlich ist.

Mortl

[adapto]

vielleicht liegts ja hier dran:

"sizeof(VertexHeader)" beim schreiben und beim lesen benutzt du "sizeof(sVertexHeader)"

[mortl]

Nein, der Vertex Header wird genauso eingelesen wie geschrieben.

[adapto]

hast du die strukturen richtig ausgerichtet?

[mortl]

Wie ausgerichtet?