Problem mit Vertex Buffer



  • Hi!
    Ich wollte einen Würfel in einen Vertex Buffer packen und ihn dann Rendern.
    Aber irgendwie kommt immer ein Fehler,den ich nicht ganz verstehe:
    C:\Dokumente und Einstellungen\Marius1\Desktop\04 - Texturen\Texturen.cpp(28) : error C2146: Syntaxfehler : Fehlendes ';' vor Bezeichner 'g_pIndexBuffer'
    C:\Dokumente und Einstellungen\Marius1\Desktop\04 - Texturen\Texturen.cpp(28) : error C2501: 'PDIRECT3DINDEXBUFFER' : Fehlende Speicherklasse oder Typbezeichner
    C:\Dokumente und Einstellungen\Marius1\Desktop\04 - Texturen\Texturen.cpp(28) : fatal error C1004: Unerwartetes Dateiende gefunden

    Hier der Code:

    #include <Windows.h>
    #include <TriBase.h>
    #include <D3DX9.h>
    #include "D:\TriBase\Beispiele\Allgemeines\InitWindow.h"
    #include "D:\TriBase\Beispiele\Allgemeines\Direct3DEnum.h"
    #include "D:\TriBase\Beispiele\Allgemeines\InitDirect3D.h"
    #include "Resource.h"
    
    // ******************************************************************
    // Struktur für einen Vertex: Position, Farbe und Texturkoordinaten
    struct SVertex
    {
    	tbVector3	vPosition;	// Position des Vertex
    	DWORD		dwColor;	// Farbe des Vertex
    	tbVector2   vTexture;   // Texturkoordinaten
    };
    
    float fTime = 1.0f;
    SDirect3DParameters g_Direct3DParameters;
    SVertex g_aTriAngleVertex[3];
    PDIRECT3DINDEXBUFFER g_pIndexBuffer = NULL;
    PDIRECT3DTEXTURE9 g_pTexture = NULL;
    PDIRECT3DVERTEXBUFFER9 g_pVertexBuffer = NULL;
    int aiIndex[36];
    
    tbResult InitScene()
    {
    
    	int* pusIndices;
    	SVertex* pVertices;
    	tbMatrix mProjection;
    	int aiIndex[36];
    	float fAspect;
    
    	//RenderStates
    	g_pD3DDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
    	g_pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
    	g_pD3DDevice->SetRenderState(D3DRS_DITHERENABLE, TRUE);
    	g_pD3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
    
    	//Samplerstates
    	g_pD3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
    	g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
    	g_pD3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
    
    	//****************************************************************
    
    	fAspect = (float) (g_Direct3DParameters.VideoMode.Width)
    		    / (float) (g_Direct3DParameters.VideoMode.Height);
    	mProjection = tbMatrixProjection(TB_DEG_TO_RAD(90.0f), fAspect, 100.0f, 0.1f);
    	g_pD3DDevice->SetTransform(D3DTS_PROJECTION, (D3DMATRIX*) (&mProjection));
    
    	//Textur setzen
    	D3DXCreateTextureFromFileEx(g_pD3DDevice,
    		                                     "Texture.bmp",
    											  D3DX_DEFAULT,
    											  D3DX_DEFAULT,
    											  D3DX_DEFAULT,
    											  0,
    											  D3DFMT_UNKNOWN,
    											  D3DPOOL_MANAGED,
    											  D3DX_FILTER_NONE,
    											  D3DX_DEFAULT,
    											  0,
    											  NULL,
    											  NULL,
    											  &g_pTexture);
    
    	g_pD3DDevice->SetTexture(0, g_pTexture);
    
    	//Positionsangaben für die Vertices des Würfels generieren
    	g_aTriAngleVertex[0].vPosition = tbVector3(-1.0f, 1.0f, -1.0f);
    	g_aTriAngleVertex[1].vPosition = tbVector3(-1.0f, 1.0f, 1.0f);
    	g_aTriAngleVertex[2].vPosition = tbVector3(1.0f, 1.0f, 1.0f);
    	g_aTriAngleVertex[3].vPosition = tbVector3(1.0f, 1.0f, -1.0f);
    	g_aTriAngleVertex[4].vPosition = tbVector3(-1.0f, -1.0f, -1.0f);
    	g_aTriAngleVertex[5].vPosition = tbVector3(-1.0f, -1.0f, 1.0f);
    	g_aTriAngleVertex[6].vPosition = tbVector3(1.0f, -1.0f, 1.0f);
    	g_aTriAngleVertex[7].vPosition = tbVector3(1.0f, -1.0f, -1.0f);
    
    	//Farbangaben für den Würfel
    	g_aTriAngleVertex[0].dwColor = (DWORD) (tbColor(1, 0, 0));
    	g_aTriAngleVertex[1].dwColor = (DWORD) (tbColor(1, 0, 0));
    	g_aTriAngleVertex[2].dwColor = (DWORD) (tbColor(1, 0, 0));
    	g_aTriAngleVertex[3].dwColor = (DWORD) (tbColor(1, 0, 0));
    	g_aTriAngleVertex[4].dwColor = (DWORD) (tbColor(1, 0, 0));
    	g_aTriAngleVertex[5].dwColor = (DWORD) (tbColor(1, 0, 0));
    	g_aTriAngleVertex[6].dwColor = (DWORD) (tbColor(1, 0, 0));
    	g_aTriAngleVertex[0].dwColor = (DWORD) (tbColor(1, 0, 0));
    
    	//Die Indizes
    	aiIndex = {0, 3, 7,  0, 7, 4,
    		       2, 1, 5,  2, 5, 6,
    			   1, 0, 4,  1, 4, 5,
    			   3, 2, 6,  3, 6, 7,
    			   0, 1, 2,  0, 2, 3,
    			   6, 5, 4,  6, 4, 7};
    
    	g_aTriAngleVertex[0].vTexture = tbVector2(0.0f, 1.0f);
    
    	//Index und Vertex Buffer erstellen
    	g_pD3DDevice->CreateVertexBuffer(8*sizeof(SVertex), 0, D3DFVF_XYZ | D3DFVF_DIFFUSE |D3DFVF_TEX 1,
    		                             D3DPOOL_MANAGED, &g_pVertexBuffer, NULL);
    	g_pD3DDevice->CreateIndexBuffer(36*2, 0, D3DFM_INDEX16, D3DPOOL_MANAGED, &g_pIndexBuffer, NULL);
    
    	//Index und Vertex Buffer sperren
    	g_pVertexBuffer->Lock(0, 0, (void**) (&pVertices), D3DLOCK_NOSYSLOCK);
    	g_pIndexBuffer->Lock(0, 0, (void**) (&pusIndices), D3DLOCK_NOSYSLOCK);
    
    	//Daten in den Vertex Buffer hineinkopieren
    	memcpy(pVertices, g_aTriAngleVertex, sizeof(g_aTriAngleVertex));
    	//Daten in den Index Buffer hineinkopieren
    	memcpy(pusIndices, aiIndex, sizeof(aiIndex));
    
    	return TB_OK;
    }
    
    tbResult Move(float fNumSecsPassed)
    {
    	fTime += 0.015f;
    	return TB_OK;
    }
    
    tbResult ExitScene()
    {
    	g_pD3DDevice->SetTexture(0, NULL);
    	TB_SAFE_RELEASE(g_pTexture);
    	TB_SAFE_RELEASE(g_pIndexBuffer);
    	TB_SAFE_RELEASE(g_pVertexBuffer);
    	g_pD3DDevice->SetStreamSource(0, NULL, 0, NULL);
    	g_pD3DDevice->SetIndices(NULL);
    	return TB_OK;
    }
    
    tbResult ExitApplication()
    {
    	ExitScene();
    	ExitDirect3D();
    	ExitWindow();
    	tbExit();
    	return TB_OK;
    }
    
    tbResult Render(float fNumSecsPassed)
    {
    	tbMatrix mTranslation;
    	tbMatrix mRotation;
    	tbMatrix mWorld;
    
    	mTranslation = tbMatrixTranslation(tbVector3(0, 0, 2));
    	mRotation = tbMatrixRotationY(TB_DEG_TO_RAD(90.0f*fTime));
    	mWorld = mRotation*mTranslation;
    	g_pD3DDevice->SetTransform(D3DTS_WORLD, (D3DMATRIX*) (&mWorld));
    
    	g_pD3DDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(50, 100, 0), 1.0f, 0);
    
    	g_pD3DDevice->BeginScene();
    
    	//Den Vertex Buffer einsetzen
    	g_pD3DDevice->SetStreamSource(0, g_pVertexBuffer, 0, sizeof(SVertex));
    
    	//Den Index Buffer einsetzen
    	g_pD3DDevice->SetIndices(g_IndexBuffer);
    
    	//Zeichnen des Bereichs
    	g_pD3DDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0);
    
    	g_pD3DDevice->EndScene();
    
    	//Den Bildpuffer sichtbar machen
    	g_pD3DDevice->Present(NULL, NULL, NULL, NULL);
    
    	return TB_OK;
    }
    
    // ******************************************************************
    // Initialisierungsfunktion
    tbResult InitApplication()
    {
    	tbResult Result;
    
    	// TriBase-Engine initialisieren
    	tbInit();
    
    	// Direct3D-Optionen abfragen (vom Benutzer gewählt)
    	Result = GetDirect3DParameters(&g_Direct3DParameters);
    	if(Result == TB_ERROR)
    	{
    		// Es trat ein Fehler auf!
    		MessageBox(NULL, "Fehler beim Abzählen!", "Fehler",
    			       MB_OK | MB_ICONEXCLAMATION);
    		return TB_ERROR;
    	}
    	else if(Result == TB_CANCELED)
    	{
    		// Der Dialog wurde abgebrochen!
    		return TB_CANCELED;
    	}
    
    	// Fenster initialisieren. Die Größe hängt vom gewählten
    	// Videomodus ab, der in der Parameterstruktur gespeichert ist.
    	if(InitWindow(g_Direct3DParameters.VideoMode.Width,
    		          g_Direct3DParameters.VideoMode.Height,
    				  "Beispielprogramm Nr. 4: Texturen",
    				  LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON1))))
    	{
    		// Fehler beim Erstellen des Fensters!
    		MessageBox(NULL, "Fehler beim Erstellen des Fensters!",
    			       "Fehler", MB_OK | MB_ICONEXCLAMATION);
    		return TB_ERROR;
    	}
    
    	// Direct3D mit den abgefragten Einstellungen initialisieren
    	if(InitDirect3D(&g_Direct3DParameters,
    		            g_hWindow))
    	{
    		// Fehler!
    		MessageBox(g_hWindow, "Fehler beim Initialisieren von Direct3D!",
    			       "Fehler", MB_OK | MB_ICONEXCLAMATION);
    		ExitApplication();
    		return TB_ERROR;
    	}
    
    	// Szene initialisieren
    	if(InitScene())
    	{
    		// Fehler!
    		MessageBox(g_hWindow, "Fehler beim Initialisieren der Szene!",
    			       "Fehler", MB_OK | MB_ICONINFORMATION);
    		ExitApplication();
    		return TB_ERROR;
    	}
    
    	// Alles OK!
    	return TB_OK;
    }
    
    // ******************************************************************
    // Windows-Hauptfunktion
    int WINAPI WinMain(HINSTANCE hInstance,
    				   HINSTANCE hPrevInstance,
    				   char* pcCmdLine,
    				   int iShowCmd)
    {
    	tbResult Result;
    
    	// Initialisierung
    	Result = InitApplication();
    	if(Result == TB_CANCELED) return 0;
    	else if(Result)
    	{
    		MessageBox(NULL, "Fehler beim Initialisieren der Anwendung!",
    			       "Fehler", MB_OK | MB_ICONEXCLAMATION);
    		return 1;
    	}
    
    	// Nachrichtenschleife
    	tbDoMessageLoop(Render, Move);
    
    	// Herunterfahren
    	ExitApplication();
    
    	return 0;
    }
    
    // ******************************************************************
    


  • Es muss "PDIRECT3DINDEXBUFFER9" heißen.
    Bei Problemen mit Programmen aus meinem Buch, benutze bitte mein Forum, da ist das besser aufgehoben: http://www.scherfgen-software.net


Log in to reply