Deklaration einer fstream/ofstream Variable führt zu crash

[Surkevin]

Der Bug tritt übrigens auch nur dann auf, wenn ich die Funktion aus der Funktion aufrufe, in der es die Allokiercrashes gibt/gab...wenn ich sie aus cleanen Funktionen aufrufe bleibt alles sauber
Super

Kevin

[flammenvogel]

Das ist allerdings merkwürdig, ich meinte das mit FILE, den ich hatte vor kurzem auch ein Problem mit dem Auslesen von Datein, habs dann durch das umstellen auf FILE gelöst.

[geiler tipp]

Hi Surkevin, am besten programmierst du alles nochmal neu und dann vernünftig.

[C++ Forumbot]

Dieser Thread wurde von Moderator/in cd9000 aus dem Forum WinAPI in das Forum C++ verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

[Surkevin]

das is vernünftig gecodet...glaubs mir...denke es hängt mir der konvertierung VS 6.0 -> .NET zusammen...

[flammenvogel]

Also ich würde dir raten (unter der vorraussetung das wirklich keine Code Fehler da ist), erstelle ein neues Projekt und binde deine ganzen Datein da nochmal ein. Damit solltest du eigentlich Fehler des Kompillers umgehen. Sonst kannst du dir zum testen auch mal Dev-Cpp laden und den Code dort versuchen zu kompelieren.

[Surkevin]

ich bin mir sehr sicher, dass der fehler nicht von mir kommt, da unter MS Dev6 keine Crashes waren!
Kevin

[flammenvogel]

Was hast du da denn überhaupt konvertiert??? Die Linker Hilsdatein oder was? Den der Code an sich muss sich ja nicht verändern oder benutzt du MFC oder etwas ähnliches??

[Surkevin]

alles reine WINAPI...msdev hat das konvertieren übernommen

[Surkevin]

jetzt crasht er wieder beim allokieren...gibt doch net....der crasht genau beim allokieren von speicher für textures...mit malloc und auch mit new....hier mal die Funktion:

void CXFile::Convert(CModel& Object, char * path, DX_Object& dd_obj, D3DXVECTOR3 position, D3DXVECTOR3 lookat)
	{

		//char* blubb = new char[10];
		//delete blubb;

		LPDIRECT3DVERTEXBUFFER9 m_meshvertexbuffer;
		LPDIRECT3DINDEXBUFFER9 m_meshindexbuffer;
		D3DVERTEXBUFFER_DESC m_vertexdesc;
		D3DINDEXBUFFER_DESC m_indexdesc;

		ModelFormatHeader m_meshheader;

		//TVertex *v;

		DWORD *dwIndicies32 = NULL;
		WORD *dwIndicies16 = NULL;

		TModelVertex *polygon = NULL;

		VOID *pVertex = NULL;
		VOID *pIndex = NULL;

		//Get Materials/Textures

		if(m_pMesh == NULL  || matMaterials == NULL)
		{
			MessageBox(dd_obj.hwnd, "Mesh wurde noch nicht erstellt!", 0, 0);
		}

		//		char debug[256];

		if(m_pMesh->GetVertexBuffer(&m_meshvertexbuffer) != D3D_OK)
		{
			MessageBox(dd_obj.hwnd, "Laden der Meshvertizen schlug fehl :(", 0, 0);
		}

		if(m_pMesh->GetIndexBuffer(&m_meshindexbuffer) != D3D_OK)
		{
			MessageBox(dd_obj.hwnd, "Fehler ;)", 0, 0);
		}

		if(m_meshvertexbuffer->GetDesc(&m_vertexdesc) != D3D_OK)
		{
			MessageBox(dd_obj.hwnd, "Infos schlugen fehl - klasse!", 0, 0);
		}

		if(m_meshindexbuffer->GetDesc(&m_indexdesc) != D3D_OK)
		{
			MessageBox(dd_obj.hwnd, "Infos schlugen fehl - klasse!", 0, 0);
		}

		DWORD dIndiciesSize = 0;
		BOOL bLowBit = TRUE;

		BOOL bXYZ = FALSE;
		BOOL bRHW = FALSE;
		BOOL bNormals = FALSE;
		BOOL bTex = FALSE;
		BOOL bDiffuse = FALSE;
		BOOL bSpecular = FALSE;
		BOOL bPointSize = FALSE;

		DWORD dwVertexSize = NULL;

		DWORD dwFVFCode = NULL;		

		if(m_vertexdesc.FVF & D3DFVF_XYZ)
		{
			bXYZ = TRUE;
			dwVertexSize += 3*sizeof(float);
			dwFVFCode |= D3DFVF_XYZ;
		}
		else if(m_vertexdesc.FVF & D3DFVF_XYZRHW)
		{
			bXYZ = TRUE;
			bRHW = TRUE;
			dwVertexSize += 4*sizeof(float);
			dwFVFCode |= D3DFVF_XYZRHW;
		}

		if(m_vertexdesc.FVF & D3DFVF_NORMAL)
		{
			bNormals = TRUE;
			dwVertexSize += 3*sizeof(float);
			dwFVFCode |= D3DFVF_NORMAL;
		}

		if(m_vertexdesc.FVF & D3DFVF_TEX1)
		{
			bTex = TRUE;
			dwVertexSize += 2*sizeof(float);
			dwFVFCode |= D3DFVF_TEX1;
		}

		if(m_vertexdesc.FVF & D3DFVF_DIFFUSE)
		{
			bDiffuse = TRUE;
			dwVertexSize += 1*sizeof(DWORD);
			dwFVFCode |= D3DFVF_DIFFUSE;
		}

		if(m_vertexdesc.FVF & D3DFVF_PSIZE)
		{
			bPointSize = TRUE;
			dwVertexSize += 1*sizeof(float);
			dwFVFCode |= D3DFVF_PSIZE;
		}

		if(m_vertexdesc.FVF & D3DFVF_SPECULAR)
		{
			bSpecular = TRUE;
			dwVertexSize += 1*sizeof(DWORD);
			dwFVFCode |= D3DFVF_SPECULAR;
		}

		if(dwFVFCode == m_vertexdesc.FVF)
		goto works;

		MessageBox(0, "Converting failed! FVF is not supported!", 0, 0);
		return;
works:

		DWORD dwVertices = (m_vertexdesc.Size/dwVertexSize);		

		BYTE* vertices = new BYTE[dwVertexSize*dwVertices];

		if(m_indexdesc.Format == D3DFMT_INDEX32)
		{

			bLowBit = FALSE;

			dwIndicies32 = new DWORD[((m_indexdesc.Size)/sizeof(DWORD))];
			dwIndicies16 = new WORD[((m_indexdesc.Size)/sizeof(DWORD))];

			if(m_meshindexbuffer->Lock(0, m_indexdesc.Size, (void**)&pIndex, D3DLOCK_READONLY) != D3D_OK)
			{
				MessageBox(dd_obj.hwnd, "gibts net", 0, 0);
			}

			memcpy(dwIndicies32, pIndex, m_indexdesc.Size);

			m_meshindexbuffer->Unlock();

			for(int i = 0; i < (signed)((m_indexdesc.Size)/sizeof(DWORD)); i++)
			{
				dwIndicies16[i] = (signed)dwIndicies32[i];
			}

			dIndiciesSize = ((m_indexdesc.Size)/sizeof(DWORD)*sizeof(WORD));

		}
		else
		{

			bLowBit = TRUE;

			dwIndicies16 = new WORD[((m_indexdesc.Size)/sizeof(WORD))];

			if(m_meshindexbuffer->Lock(0, m_indexdesc.Size, (void**)&pIndex, D3DLOCK_READONLY) != D3D_OK)
			{
				MessageBox(dd_obj.hwnd, "gibts net", 0, 0);
			}

			memcpy(dwIndicies16, pIndex, m_indexdesc.Size);

			m_meshindexbuffer->Unlock();

			dIndiciesSize = m_indexdesc.Size;

		}

		polygon = new TModelVertex[dwVertices];

		if(m_meshvertexbuffer->Lock(0, m_vertexdesc.Size, (void**)&pVertex, D3DLOCK_READONLY) != D3D_OK)
		{
			MessageBox(dd_obj.hwnd, "Der Vertexbuffer konnte beim Konvertieren nicht gelockt werden!", "Error!", 0);
		}

		memcpy(vertices, pVertex, m_vertexdesc.Size);

		m_meshvertexbuffer->Unlock();

		//Convert the XFile Vertices to our Vertices
		TVertex* v = new TVertex[dwVertices];

		MessageBox(0, "Alles aus dem Mesh gelesen", 0, 0);

		{for(int i = 0; i < (int)dwVertices; i++)
		{
			if(bXYZ)
			memcpy(&v[i].position, (BYTE*)vertices + i*dwVertexSize, sizeof(D3DXVECTOR3));

			if(bTex)
			memcpy(&v[i].tu, (BYTE*)vertices + i*dwVertexSize + dwVertexSize - 2*sizeof(float), 2*sizeof(float));
		}}

		MessageBox(0, "Alles Teil kopiert", 0, 0);

		//Convert to TModelPolygon

		{for(unsigned int i = 0; i < dwVertices; i++)
		{
			polygon[i].v = v[i];
		}}

		{for(unsigned int i = 0; i < ((dIndiciesSize/sizeof(WORD))/3); i = i + 3)
		{
			D3DVECTOR vNormal = GetTriangeNormal(&D3DXVECTOR3(v[dwIndicies16[i]].position.x, v[dwIndicies16[i]].position.y, v[dwIndicies16[i]].position.z), 
				&D3DXVECTOR3(v[dwIndicies16[i + 1]].position.x, v[dwIndicies16[i + 1]].position.y, v[dwIndicies16[i + 1]].position.z),
				&D3DXVECTOR3(v[dwIndicies16[i + 2]].position.x, v[dwIndicies16[i + 2]].position.y, v[dwIndicies16[i + 3]].position.z));

			if(!bTex)
			{
				v[dwIndicies16[i]].tu = 0;
				v[dwIndicies16[i]].tv = 0;

				v[dwIndicies16[i + 1]].tu = 1;
				v[dwIndicies16[i + 1]].tv = 1;

				v[dwIndicies16[i + 2]].tu = 0;
				v[dwIndicies16[i + 2]].tv = 1;
			}

			v[dwIndicies16[i]].nx = vNormal.x;
			v[dwIndicies16[i]].ny = vNormal.y;
			v[dwIndicies16[i]].nz = vNormal.z;

			v[dwIndicies16[i + 1]].nx = vNormal.x;
			v[dwIndicies16[i + 1]].ny = vNormal.y;
			v[dwIndicies16[i + 1]].nz = vNormal.z;

			v[dwIndicies16[i + 2]].nx = vNormal.x;
			v[dwIndicies16[i + 2]].ny = vNormal.y;
			v[dwIndicies16[i + 2]].nz = vNormal.z;
		}}

		//Get Length of TextureText
		int iLength = 0;
		{
			for(int i = 0; i < (signed)m_MaterialsCount; i++)
			{
				if(matMaterials[i].pTextureFilename != NULL)
				{
					//MessageBox(0, matMaterials[i].pTextureFilename, "wtf", 0);

					DeletePathOfTexture(matMaterials[i].pTextureFilename);
					//MessageBox(0, matMaterials[i].pTextureFilename, 0, 0);
					iLength = iLength + strlen(matMaterials[i].pTextureFilename) + strlen("\xd");
				}
				else
				{
					iLength = iLength + strlen("\xd");
				}
			}
		}

		char debug[256];
		wsprintf(debug, "Textureslength: %i", iLength);
		MessageBox(0, debug, 0, 0);

Hier crashts:

textures = (char*)malloc(iLength + 256);  //CRAAAAAAAAASH

		MessageBox(0, "und los gehts", 0, 0);
		//Set Textures
		ZeroMemory(textures, iLength+255);

		MessageBox(0, "1", 0, 0);

		{
			for(int i = 0; i < (signed)m_MaterialsCount; i++)
			{
				if(matMaterials[i].pTextureFilename != NULL){
					strcat(textures, matMaterials[i].pTextureFilename);
				}
				strcat(textures, "\xd");
				//MessageBox(0, "STRCAT", 0, 0);

			}
		}
		MessageBox(0, "2", 0, 0);

		//SetMaterials
		m_usedMaterials = new D3DMATERIAL9[m_MaterialsCount];
		{
			for(int i = 0; i < (signed)m_MaterialsCount; i++)
			{
				m_usedMaterials[i] = matMaterials[i].MatD3D;
				m_usedMaterials[i].Ambient = m_pMeshMaterials[i].Diffuse;
			}
		}

		MessageBox(0, "3", 0, 0);

		for(int i = 0; i < (signed)m_MaterialsCount; i++)
		{
			for(int count = attribrange[i].VertexStart; count < (signed)(attribrange[i].VertexStart + attribrange[i].VertexCount); count++)
			{
				polygon[count].ID = i;
			}
		}

		MessageBox(0, "4", 0, 0);

		m_meshheader.cb = sizeof(ModelFormatHeader);
		m_meshheader.iPolygons = ((dIndiciesSize/sizeof(WORD))/3);
		m_meshheader.iVersion = 1;
		m_meshheader.iVertizes = dwVertices;
		m_meshheader.iSizeOfVertizes = (dwVertices*sizeof(TModelVertex));
		m_meshheader.iSizeOfIndexbuffer = dIndiciesSize;
		m_meshheader.iSizeOfTextures = strlen(textures)*sizeof(char);
		m_meshheader.iSizeOfMaterials = sizeof(D3DMATERIAL9)*m_MaterialsCount;
		m_meshheader.cameralookat = lookat;
		m_meshheader.cameraposition = position;

		Object.WriteModelFile(path, polygon, dwIndicies16, m_meshheader, 
			m_meshheader.iSizeOfVertizes, m_meshheader.iSizeOfIndexbuffer, textures, m_usedMaterials);

		MessageBox(dd_obj.hwnd, "Successfully saved the Modelfile", "SUCCESS!", 0);

		delete [] v;
		delete [] dwIndicies16;
		if(!bLowBit)
		{
			delete [] dwIndicies32;
		}
		delete [] polygon;
		free(textures);
		delete [] vertices;

	}

[Blacksierra]

ok ich spiel erst seit ner woche mit c++ rum aber mal so out of the blue:
ich denke es haengt mit dem var namen filestream zusammen - compiler hat wohl probleme mit der gleichnamigen .net klasse FileStream.
hoffe das hilft !!

[Surkevin]

hi, ne *g* daran kann das nicht liegen
muss ein Bug in meinem .NET sein...bei nem Kumpel von mir verreckt es nämlich nicht wenn er es kompiliert...hat ne neuere .NET - Version!
Danke trotzdem
Kevin