Was kann ich gegen dieses Problem machen? (DirectX & C++)

[DaMiNaToR]

Hallo!
Sry für die schlechte Überschrift, aber mir ist keine bessere eingefallen.
Ich bin dabei DirectX unter c++ zu lernen, und versuche dazu ein tutorial umzuändern, damit ich etwas lerne.

In diesem Fall will ich ein Bild von einem Elefanten von links nach rechts fliegen lassen. Ganz simpel.

Jedoch frisst das Programm pro Sekunde 15 MB Arbeitsspeicher mehr

Ich denke das liegt daran, das irgendwo imemr wieder Variablen neu erstellt werden.

Ich denke mal es liegt an der funktion "SetNewGeometry". Nur leider weiss ich keine Lösung, wie kann ich neue Koordinaten für das Polygon eingeben?

Also, am besten nur die Funktionen Render und SetNewGeometry angucken.
Eine rasche Antwort wäre super, damit ich weiterarbeiten kann
Weil ich habe leider keine Idee

In SetNewGeometry sollten dann die kords des Rechtecks immer weiter nach links gehen. Das würd ich dann machen, aber ich habe ja jetzt dieses Problem.

wen etwas unklar ist, ode rdas komplette Projekt mit allen Dateien gewünscht wird, dann bitte sofort miiteilen.

Ich bitte um hilfe

Das ist das Projekt--->>>

/*-----------------------------------------------------------------------------*/
/*------|	Autor	: Andre Lahs 										|------*/
/*------|	Datum	: 07.02.2003										|------*/
/*------|	Inhalt	: Texturemapping und Index Buffer					|------*/
/*------|   Kontakt : webmaster@x-tutorials.de							|------*/
/*-----------------------------------------------------------------------------*/

/////////////////////////////////////////////////////////////////////////////////
// Diese Tutorial zeigt die Benutzung von Index Buffern und das Texturemapping //
/////////////////////////////////////////////////////////////////////////////////

#include <d3dx8.h>
#include <mmsystem.h>
#include "resource.h"
#pragma comment(lib, "d3dx8.lib")
#pragma comment(lib, "d3d8.lib" )
#pragma comment(lib, "winmm.lib")

////////////////////////////////////////////////////////////////////////////////
// Vertexstruktur															  //
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
// Um Polygone mit einer Textur zu versehen, muss jedem Vertex ein Textur-    //
// koordinatenpaar zugewiesen werden. Diese Koordinatenpaar ( tu, tv ) fügen  //
// wir der Vertexstrucktur hinzu und erweitern die Konstante um den Parameter //
// D3DFVF_TEX1, wodurch Direct3D dann weiß, dass unser Vertex auch Textur-	  //
// Koordinaten enthält.														  //
////////////////////////////////////////////////////////////////////////////////

struct TVertex
{
	D3DXVECTOR3	position;	// Ortsvektor
	DWORD		color;		// Vertexfarbe
	FLOAT       tu, tv;		// Texturkoordinaten
};

// Diese Konstante beschreibt unser Vertexformat
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE|D3DFVF_TEX1)

/////////////////////////////////////////////////////////////////////////////////
// Globale Variablen deklarieren											   //
/////////////////////////////////////////////////////////////////////////////////

HWND					handle			= NULL;	// Fensteradresse									   
BOOL					keys[256];				// Mit diesem Array behandeln wir Tastenereignisse	   
BOOL					bActive			= FALSE;// Aktivitätsstatus des Programms	   
LPDIRECT3D8				D3D_Object		= NULL; // Hauptobjekt von D3D
LPDIRECT3DDEVICE8		D3D_Device		= NULL; // Schnittstelle zw. D3D und Hardware
LPDIRECT3DVERTEXBUFFER8 D3D_VertexBuffer= NULL; // VertexBuffer
LPDIRECT3DINDEXBUFFER8  D3D_IndexBuffer = NULL; // IndexBuffer
LPDIRECT3DTEXTURE8		D3D_Texture		= NULL; // Textur 

/////////////////////////////////////////////////////////////////////////////////
// Konstanten																   //
/////////////////////////////////////////////////////////////////////////////////

#define				WIN_LEFTX	  50	// Linke X-Koordinate
#define				WIN_LEFTY	  50	// Linke Y-Koordinate
#define				WIN_WIDTH	400 // Breite
#define				WIN_HEIGHT	400 // Höhe

/////////////////////////////////////////////////////////////////////////////////
// Funktionsdeklaration														   //
/////////////////////////////////////////////////////////////////////////////////
// Fensterroutine
LRESULT	WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam ); 
// Routine zum Einrichten von Direct3D
BOOL	Init();
// Routine um Geometrie einzurichten
BOOL	SetGeometry(); 
// Routine um Transformationen zu bewrkstelligen
VOID	SetMatrices();
// Routine zum Zerstören der erstellten Direct3D-Objekte
VOID	Destroy();
// Routine zum Rendern der Szene
VOID	Render();

VOID SetNewGeometry();

//////////////////////////////////////////////////////////////////////////
// Direct3D einrichten													//
//////////////////////////////////////////////////////////////////////////
BOOL Init()
{
	// Als erstes müssen wir das D3D_Objekt erstellen
	if (NULL==( D3D_Object = Direct3DCreate8( D3D_SDK_VERSION )))
				return FALSE;

	// Wir holen uns nun die aktuellen Desktopeinstellungen(Auflösung...)
	D3DDISPLAYMODE d3ddm;
    if( FAILED( D3D_Object->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm )))
        return FALSE;

	// Als nächstes legen wir Einstellungen für den D3D_Device fest		
	D3DPRESENT_PARAMETERS d3dpp; 
    ZeroMemory( &d3dpp, sizeof(d3dpp) );
    // Wir wollen in einem Desktop-Window darstellen						
	d3dpp.Windowed = TRUE;
	// Den SwapEffect stellen wir auf "discard", die schnellste Einstellung 
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    // Der Backbuffer übernimmt die Desktopeinstellungen					
	d3dpp.BackBufferFormat = d3ddm.Format;

	// Endlich können wir unseren D3D_Device erstellen					
	if( FAILED( D3D_Object->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, handle,
                                      D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                      &d3dpp, &D3D_Device )))
	{
		return FALSE;
	}

	// Wir schalten das Backfaceculling aus, weil sonst nur die Seite gezeichnet wird,
	// wo die Vertices im Uhrzeigersinn angeordnet sind.
	D3D_Device->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
	// Wir müssen das Licht ausstellen, sonst sehen wir nix, weil wir
	// keine Materialeigenschaften verteilt haben.
	D3D_Device->SetRenderState( D3DRS_LIGHTING, FALSE );

	return TRUE;
}

//////////////////////////////////////////////////////////////////////////
// Initialisierte Objekte wieder freigeben								//
//////////////////////////////////////////////////////////////////////////
VOID Destroy()
{
	if( D3D_Texture != NULL )
        D3D_Texture->Release();

	if( D3D_IndexBuffer != NULL)
		D3D_IndexBuffer->Release();

	if( D3D_VertexBuffer != NULL)
		D3D_VertexBuffer->Release();

    if( D3D_Device != NULL) 
        D3D_Device->Release();

    if( D3D_Object != NULL)
        D3D_Object->Release();
}

//////////////////////////////////////////////////////////////////////////
// Vertexdaten, Indizes und Texturen einrichten							//
//////////////////////////////////////////////////////////////////////////

BOOL SetGeometry()
{
//////////////////////////////////////////////////////////////////////////
// Wir wollen ein Quadrat erstellen, das mit einer Textur gemappt wird, //
// dazu erstellen wir vier Vertices mit Texturkoordinaten. Um sich ein  //
// besseres Bild von der Anordnug der Texturkkordinaten zu machen, könnt//
// ihr euch die folgende Abbildung ansehen. Wie man sieht, sind Texturen//
// in ihrer Grundform stets viereckig. Die linke obere Ecke hat die     //
// Koordinaten (0.0/0.0) und die rechte untere ( 1.0/1.0).				//
//////////////////////////////////////////////////////////////////////////
/* 
	Anordnung der Texturkoordinaten ( tu/tv )

	  0.0/0.0 *-------------* 1.0/0.0 
			  |				|
			  |				|
			  |				|
			  |				|
			  |				|
			  |				|
			  |				|
	  0.0/1.0 *-------------* 1.0/1.0
*/
	/////////////////////////////////////////////////////////////////////
	// Vertexdaten für das Quadrat erstellen.						   //
	/////////////////////////////////////////////////////////////////////

	TVertex v[4];	

	static float x1,x2,x3,x4;

	x1=-0.5f;x2=0.5f;
	x3=-0.5f;x4=0.5f;

	v[0].position = D3DXVECTOR3(-2.0f,0.5f, 0.0f);
	v[0].color	  = D3DCOLOR_XRGB(255,255,0);
	v[0].tu		  = 0.0f;
	v[0].tv		  = 0.0f;
	v[1].position = D3DXVECTOR3( -1.0f, 0.5f,0.0f);
	v[1].color	  = D3DCOLOR_XRGB(0,255,0);
	v[1].tu		  = 1.0f;
	v[1].tv		  = 0.0f;
	v[2].position = D3DXVECTOR3( -2.0f,-0.5f, 0.0f);
	v[2].color	  = D3DCOLOR_XRGB(255,255,255);
	v[2].tu		  = 0.0f;
	v[2].tv		  = 1.0f;
	v[3].position = D3DXVECTOR3( -1.0f,-0.5f, 0.0f);
	v[3].color	  = D3DCOLOR_XRGB(255,0,0);
	v[3].tu		  = 1.0f;
	v[3].tv		  = 1.0f;

	////////////////////////////////////////////////////////////////////
	// Indexbuffer erstellen										  //
	////////////////////////////////////////////////////////////////////

	// Zuerst erstellen wir die Inizesliste, jeweils Drei Indizes ergeben
	// ein Polygon

	WORD wIndices[6] =	{ 
							0,1,2, // Dreieck 1
							1,2,3  // Dreieck 2
						};

	// Einen IndexBuffer zu erstellen, erfolgt analog zum Erstellen eines
	// VertexBuffers. Der Parameter D3DFMT_INDEX16 gibt an, dass wir eine
	// Indexliste des Typen WORD und nicht DWORD (D3DFMT_INDEX32) benutzen

	if ( FAILED(D3D_Device->CreateIndexBuffer(sizeof(wIndices),D3DUSAGE_WRITEONLY
											,D3DFMT_INDEX16,D3DPOOL_MANAGED, &D3D_IndexBuffer)))
	{
		return FALSE;
	}

	VOID *pInd;	// Pointer auf die IndexDaten

	// IndexBuffer schließen
	if ( FAILED(D3D_IndexBuffer->Lock(0,sizeof(wIndices),(BYTE**)&pInd,0)))
	{
		return FALSE;
	}

	// Indizes kopieren
	memcpy(pInd,&wIndices[0],sizeof(wIndices));

	// IndexBuffer aufschließen
	D3D_IndexBuffer->Unlock();

	////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////////////////////////////////////
	// VertexBuffer erstellen											  //
	////////////////////////////////////////////////////////////////////////

	// Nun müssen wir einen Vertexbuffer erstellen und die Vertex-Daten
	// In ihn hineinkopieren
	if( FAILED( D3D_Device->CreateVertexBuffer( sizeof(v),
                                                  D3DUSAGE_WRITEONLY, D3DFVF_CUSTOMVERTEX,
                                                  D3DPOOL_DEFAULT, &D3D_VertexBuffer)))
    {
        return FALSE;
    }

	VOID* pVertex;	// Pointer auf die Vertices

    // VertexBuffer schließen
	D3D_VertexBuffer->Lock( 0, sizeof(v), (BYTE**)&pVertex, 0 );

	// Vertexdaten kopieren
	memcpy( pVertex, v, sizeof(v) );

	// Vertexbuffer aufschließen
	D3D_VertexBuffer->Unlock();

	////////////////////////////////////////////////////////////////////
	// Laden einer Textur											  //
	////////////////////////////////////////////////////////////////////

	////////////////////////////////////////////////////////////////////
	// Wir machen es uns jetzt erstmal einfach und nutzen Funktionen  //
	// von Direct3D um die Textur zu laden. Sie haben den Vorteil,dass//
	// sie viele verschiedene Typen von Bitmaporientierten Bild-	  //
	// formaten laden können, wie zum Beispiel *.BMP, *.GIF, *.JPG,   //
	// *.TGA u.a.													  //
	////////////////////////////////////////////////////////////////////
	if( FAILED( D3DXCreateTextureFromFile( D3D_Device, "textur.tga",
                                           &D3D_Texture ) ) )
        return FALSE;

	////////////////////////////////////////////////////////////////////

	return TRUE;

}

/////////////////////////////////////////////////////////////////////////
// Matrizen einrichten												   //
/////////////////////////////////////////////////////////////////////////

VOID SetMatrices()
{
	/////////////////////////////////////////////////////////////////////
    // SichtMatrix erstellen										   //
	/////////////////////////////////////////////////////////////////////
    D3DXMATRIX matView;
    D3DXMatrixLookAtLH( &matView, &D3DXVECTOR3( 0.0f, 0.0f,-5.0f ),
                                  &D3DXVECTOR3( 0.0f, 0.0f, 0.0f ),
                                  &D3DXVECTOR3( 0.0f, 1.0f, 0.0f ));
    D3D_Device->SetTransform( D3DTS_VIEW, &matView );

	/////////////////////////////////////////////////////////////////////
	// ProjektionsMatrix erstellen									   //
	/////////////////////////////////////////////////////////////////////
	D3DXMATRIX matProj;
    D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI/4, 1.0f, 1.0f, 100.0f );
    D3D_Device->SetTransform( D3DTS_PROJECTION, &matProj );

	/////////////////////////////////////////////////////////////////////
	// Rotation durch Matrix hervorrufen							   //
	/////////////////////////////////////////////////////////////////////
	D3DXMATRIX matWorld;
    D3DXMatrixRotationY( &matWorld, timeGetTime()/1000.0f );
    D3D_Device->SetTransform( D3DTS_WORLD, &matWorld );
}

/////////////////////////////////////////////////////////////////////////
// Szene render														   //
/////////////////////////////////////////////////////////////////////////
VOID Render()
{
	// Ersteinmal die Matrixeinstellungen setzten
//	SetMatrices();

	SetNewGeometry();

	// Die Funktion Clear() löscht den Fensterinhalt mit einer Farbe		
    D3D_Device->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(255,255,255), 1.0f, 0 );

	// Hier beginnen die eigentlichen Renderanweisungen					
    D3D_Device->BeginScene();

		/////////////////////////////////////////////////////////////////////
		// Quadrat rendern												   //
		/////////////////////////////////////////////////////////////////////

		// Wir müssen die Textur setzen, damit Direct3D weiß welche Textur zu 
		// mappen ist
		D3D_Device->SetTexture( 0, D3D_Texture );

		// Quelle der Vertesdaten angeben
		D3D_Device->SetStreamSource(0,D3D_VertexBuffer,sizeof(TVertex));
		// Unsere Vertexkonstante als Vertexshader setzen
		D3D_Device->SetVertexShader(D3DFVF_CUSTOMVERTEX);
		// Den IndexBuffer angeben
		D3D_Device->SetIndices(D3D_IndexBuffer,0);
		// Indizierte Primitive rendern. 
		// Wir wollen eine Dreiecksliste rendern, die aus vier Vertices
		// und 2 Polygonen besteht.
		D3D_Device->DrawIndexedPrimitive(

								D3DPT_TRIANGLELIST,	// Typ der Primitive
								0,					// erster Vertex der zu benutzen ist
								4,					// Anzahl der zu nutzenden Vertices
								0,					// Startindex
								2					// Anzahl der Polygone
										);

		//////////////////////////////////////////////////////////////////////

	// Hier enden die Renderanweisungen									
    D3D_Device->EndScene();

	// Diese Funktion macht dann alles was wir rendern im Fenster sichtbar
    D3D_Device->Present( NULL, NULL, NULL, NULL );
}

/////////////////////////////////////////////////////////////////////////////////
// Das eigentliche Programm													   //
/////////////////////////////////////////////////////////////////////////////////

INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR, INT )
{
	// Fensterklasse
	WNDCLASS wc;

	wc.hInstance		= hInst;	// Handle der Instanz
	wc.lpszClassName	= "MyWin";	// Name der Fensterklasse
	wc.lpfnWndProc		= MsgProc;	// Die Fensterroutine zum Verarbeiten von Meldungen
	wc.style			= 0;		// Standard Fenster
	wc.hIcon			= LoadIcon(hInst,MAKEINTRESOURCE(IDI_ICON1));// Icon
	wc.hCursor			= 0;		// Keinen besonderen Cursor		
	wc.lpszMenuName		= NULL;		// Kein Menü
	wc.cbClsExtra		= 0;		// Keine Keine Extras
	wc.cbWndExtra		= 0;
	wc.hbrBackground    = (HBRUSH)GetStockObject(WHITE_BRUSH); // Fenster weiß färben

    // Fensterklasse registrieren
	RegisterClass( &wc );

	// Fenstergröße korrekt berechnen lassen
	RECT rc;
	SetRect(&rc,0,0,WIN_WIDTH,WIN_HEIGHT);
	AdjustWindowRect(&rc,WS_SYSMENU,TRUE);

	/////////////////////////////////////////////////////////////////////////////
	// Jetzt können wir das Fenster erstellen. Die Funktion CreateWindow() gibt//
	// den Fenster-Handle zurück. Ist er gleich NULL dann ist das Erstellen ge-//
	// scheitert.															   //
	/////////////////////////////////////////////////////////////////////////////

	handle = CreateWindow( 

				"MyWin",					// Name der Fensterklasse
				"Tutorial 4: Texturmapping und Index Buffer", // Titel
                WS_OVERLAPPEDWINDOW,		// Fensterstil, hier ganz normal
				WIN_LEFTX,					// obere Ecke X
				WIN_LEFTY,					// obere Ecke Y
				(rc.right	- rc.left),		// Breite
				(rc.bottom  - rc.top ),		// Höhe
                GetDesktopWindow(),			// Als Desktopfenster, kein Elternfenster
				NULL,						// kein Menü
				wc.hInstance,				// Handle der Klasseninstanz
				NULL 
						 );		

	/////////////////////////////////////////////////////////////////////////////
	// Es sollte stets überprüft werden, ob Initialisierungen geklappt haben,  //
	// denn wenn nicht, muss man die Fehler abfangen, damit das Programm nicht //
	// abstürzt.															   //
	/////////////////////////////////////////////////////////////////////////////
	if ((handle != NULL) && Init() && SetGeometry())
		bActive = TRUE;
	else
	    bActive = FALSE;

	if (bActive)
	{

		// Fenster anzeigen lassen und aktualisieren						   
        ShowWindow( handle, SW_SHOWDEFAULT );
        UpdateWindow( handle );

        // Meldeschleife
		MSG msg; // Variable, um Meldung aufzunehmen

        while( (msg.message!=WM_QUIT) && (!keys[VK_ESCAPE]) )				
		{	
			// Meldungen holen
			if( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )
			{
				// TastenSchlüssel gegebenenfalls übersetzen
				TranslateMessage( &msg );	
				// An MsgProc() weiterleiten
				DispatchMessage( &msg );
			}
			else
				/////////////////////////////////////////////////////////////////////
				// Nach dem die Meldeschleife alle Meldungen verarbeitet hat, kann //
				// gerendert werden.											   //
				/////////////////////////////////////////////////////////////////////
				Render();
		}

    }

	Destroy();
	// Bevor das Programm beendet wird, muss die Fensterklasse
	// wieder bei Windows abgemeldet werden.
	UnregisterClass( "Window1", wc.hInstance );

	return 0;
}
////////////////////////////////////////////////////////////////////////////////
// Die Fensterroutine														  //
////////////////////////////////////////////////////////////////////////////////
LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
    switch( msg )
    {
    case WM_DESTROY:
		{
			// Programm beenden
			PostQuitMessage( 0 );
			return 0;
		}

	// Auf Tastatureingaben reagieren
	case WM_KEYDOWN:
		{	
			keys[wParam] = TRUE;
			return 0;
		}

	case WM_KEYUP:
		{
			keys[wParam] = FALSE;
			return 0;
		}
	}

	/////////////////////////////////////////////////////////////////////////////
	// So, jetzt wurden nicht alle Meldungen verarbeitet, die übrigen geben wir//
	// an Windows zurück													   //
	/////////////////////////////////////////////////////////////////////////////
    return DefWindowProc( hWnd, msg, wParam, lParam );	
}

VOID SetNewGeometry()
{
//////////////////////////////////////////////////////////////////////////
// Wir wollen ein Quadrat erstellen, das mit einer Textur gemappt wird, //
// dazu erstellen wir vier Vertices mit Texturkoordinaten. Um sich ein  //
// besseres Bild von der Anordnug der Texturkkordinaten zu machen, könnt//
// ihr euch die folgende Abbildung ansehen. Wie man sieht, sind Texturen//
// in ihrer Grundform stets viereckig. Die linke obere Ecke hat die     //
// Koordinaten (0.0/0.0) und die rechte untere ( 1.0/1.0).				//
//////////////////////////////////////////////////////////////////////////
/* 
	Anordnung der Texturkoordinaten ( tu/tv )

	  0.0/0.0 *-------------* 1.0/0.0 
			  |				|
			  |				|
			  |				|
			  |				|
			  |				|
			  |				|
			  |				|
	  0.0/1.0 *-------------* 1.0/1.0
*/
	/////////////////////////////////////////////////////////////////////
	// Vertexdaten für das Quadrat erstellen.						   //
	/////////////////////////////////////////////////////////////////////

	static TVertex v[4];	

	static float x1,x2,x3,x4;

	x1=-0.5f;x2=0.5f;
	x3=-0.5f;x4=0.5f;

	v[0].position = D3DXVECTOR3(-2.0f,0.5f, 0.0f);
	v[0].color	  = D3DCOLOR_XRGB(255,255,0);
	v[0].tu		  = 0.0f;
	v[0].tv		  = 0.0f;
	v[1].position = D3DXVECTOR3( -1.0f, 0.5f,0.0f);
	v[1].color	  = D3DCOLOR_XRGB(0,255,0);
	v[1].tu		  = 1.0f;
	v[1].tv		  = 0.0f;
	v[2].position = D3DXVECTOR3( -2.0f,-0.5f, 0.0f);
	v[2].color	  = D3DCOLOR_XRGB(255,255,255);
	v[2].tu		  = 0.0f;
	v[2].tv		  = 1.0f;
	v[3].position = D3DXVECTOR3( -1.0f,-0.5f, 0.0f);
	v[3].color	  = D3DCOLOR_XRGB(255,0,0);
	v[3].tu		  = 1.0f;
	v[3].tv		  = 1.0f;

	////////////////////////////////////////////////////////////////////
	// Indexbuffer erstellen										  //
	////////////////////////////////////////////////////////////////////

	// Zuerst erstellen wir die Inizesliste, jeweils Drei Indizes ergeben
	// ein Polygon

	WORD wIndices[6] =	{ 
							0,1,2, // Dreieck 1
							1,2,3  // Dreieck 2
						};

	// Einen IndexBuffer zu erstellen, erfolgt analog zum Erstellen eines
	// VertexBuffers. Der Parameter D3DFMT_INDEX16 gibt an, dass wir eine
	// Indexliste des Typen WORD und nicht DWORD (D3DFMT_INDEX32) benutzen

D3D_Device->CreateIndexBuffer(sizeof(wIndices),D3DUSAGE_WRITEONLY ,D3DFMT_INDEX16,D3DPOOL_MANAGED, &D3D_IndexBuffer);

	VOID *pInd;	// Pointer auf die IndexDaten

	// IndexBuffer schließen
	D3D_IndexBuffer->Lock(0,sizeof(wIndices),(BYTE**)&pInd,0);

	// Indizes kopieren
	memcpy(pInd,&wIndices[0],sizeof(wIndices));

	// IndexBuffer aufschließen
	D3D_IndexBuffer->Unlock();

	////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////////////////////////////////////
	// VertexBuffer erstellen											  //
	////////////////////////////////////////////////////////////////////////

	// Nun müssen wir einen Vertexbuffer erstellen und die Vertex-Daten
	// In ihn hineinkopieren
	D3D_Device->CreateVertexBuffer( sizeof(v),D3DUSAGE_WRITEONLY, D3DFVF_CUSTOMVERTEX, D3DPOOL_DEFAULT, &D3D_VertexBuffer);

	VOID* pVertex;	// Pointer auf die Vertices

    // VertexBuffer schließen
	D3D_VertexBuffer->Lock( 0, sizeof(v), (BYTE**)&pVertex, 0 );

	// Vertexdaten kopieren
	memcpy( pVertex, v, sizeof(v) );

	// Vertexbuffer aufschließen
	D3D_VertexBuffer->Unlock();

}

Vielen dank an alle für Lösungsvorschläge!

mFG
DaMiNaToR

[TGGC]

DaMiNaToR schrieb:

Nur leider weiss ich keine Lösung, wie kann ich neue Koordinaten für das Polygon eingeben?

Ich habe mir den Code nicht durchgelesen. Aber es gibt IMHO keinen Grund neue Koordinaten "einzugeben". Wenn doch, dann gib die alten frei.

Bye, TGGC \-/

[DaMiNaToR]

Es geht mir ja darum, das Viereck von links nach rechts zu bewegen, also müssen doch jedes Mal die X Koords z.B. + 0.05 sein.
doch wie und wo kann ich das machen?
Also sie aktualisieren?

Darum gehts mir

[TGGC]

Da gibts mehrere Möglichkeiten. Schau z.B. IDirect3DDevice9::SetTransform an.

Bye, TGGC \-/

[DaMiNaToR]

Ich würd saber der Einfachheit erstmal nur mit aktualisieren der Koords machen.
Das klappt ja auch!
Nur sicherlich ist meine funktion da an der falschen Stelle

Aber wo liegt eigentlich der Fehler, das das Programm ständig mehr Arbeitsspeicher verbrauchen lässt?

[jube]

Hi,
du hast doch deine MessageSchleife. Und dann machst du dir einfach noch zwei Funktionen, eine die rendern kann und die andere bewegt das Objekt. In jedem Durchgang erhöst du dann die globalen Vertices Koordinaten um einen bestimmten Wert und des rendern müsste klar sein.
mfg juli

[DaMiNaToR]

@ jube
Und was reicht zum Bewegen des Objektes?
Also ich aktualisiere die Variable TVertex, was muss dann noch sein?
Muss auch die Textur laden funktion wieder in die Schleife?

sorry, aber wie gesagt fange erst gerade damit an.

Weil so wie ich es habe, die komplette Funktion SetNewGeometry, lässt wohl den Arbeitsspeicher voll werden, da stimmt was nicht.

[TGGC]

DaMiNaToR schrieb:

Ich würd saber der Einfachheit erstmal nur mit aktualisieren der Koords machen.

Ich würd saber der Einfachheit erstmal nur ohne aktualisieren der Koords machen.

Bye, TGGC \-/

[Babbo]

öhm, ich hoffe das hat jetzt noch keiner gesagt:
dir ist doch aber schon klar, dass du in setnewgeometry immer einen neuen vertex und index buffer erstellst...? ohne die alten zu releasen...? oder hab ich das jetzt falsch gesehen? sorry, wenn ja, dürft ihr mich schlagen.
nee, mal im ernst, was an deiner funktion nicht stimmt ist meiner meinung nach genau das, du erstellst bei jedem rendern einen neuen vertex- und indexbuffer, ohne die alten zu löschen. nimm aus setnewgeometry einfach die CreateVertex/IndexBuffer methoden raus.

"Was muss dann noch sein?"
der rest der funktion kann so bleiben glaub ich, vertex und index buffer locken und aktualisierte daten reinschreiben.

"Muss auch die Textur laden funktion wieder in die Schleife? "
um gottes willen nein., sonst würde das gleiche passieren, immer mehr ram würde verschwendet.

hoffe, ich hab jetzt nichts sinnloses oder so geschrieben...
cya

[DaMiNaToR]

Juhu danke, es klappt jetzt
Danke Babo das wars! super!

Jetzt habe ich es so->

VOID SetNewGeometry()
{

	static TVertex v[4];	

	static float x1=-0.5f,x2=0.5f;
	static float x3=-0.5f,x4=0.5f;

	x1=x1+0.0005f;x2=x2+0.0005f;

	x3=x3+0.0005f;x4=x4+0.0005f;

	v[0].position = D3DXVECTOR3(x1,0.5f, 0.0f);
	v[0].color	  = D3DCOLOR_XRGB(255,255,0);
	v[0].tu		  = 0.0f;
	v[0].tv		  = 0.0f;
	v[1].position = D3DXVECTOR3( x2, 0.5f,0.0f);
	v[1].color	  = D3DCOLOR_XRGB(0,255,0);
	v[1].tu		  = 1.0f;
	v[1].tv		  = 0.0f;
	v[2].position = D3DXVECTOR3( x3,-0.5f, 0.0f);
	v[2].color	  = D3DCOLOR_XRGB(255,255,255);
	v[2].tu		  = 0.0f;
	v[2].tv		  = 1.0f;
	v[3].position = D3DXVECTOR3( x4,-0.5f, 0.0f);
	v[3].color	  = D3DCOLOR_XRGB(255,0,0);
	v[3].tu		  = 1.0f;
	v[3].tv		  = 1.0f;

	WORD wIndices[6] =	{ 
							0,1,2, // Dreieck 1
							1,2,3  // Dreieck 2
						};
	VOID *pInd;	// Pointer auf die IndexDaten

	D3D_IndexBuffer->Lock(0,sizeof(wIndices),(BYTE**)&pInd,0);

	memcpy(pInd,&wIndices[0],sizeof(wIndices));

	D3D_IndexBuffer->Unlock();

	VOID* pVertex;	// Pointer auf die Vertices

	D3D_VertexBuffer->Lock( 0, sizeof(v), (BYTE**)&pVertex, 0 );

	memcpy( pVertex, v, sizeof(v) );
	D3D_VertexBuffer->Unlock();

}

Der Elefant wird verschoben, so habe ichs mir vorgestellt.

Jetzt noch 2 kleine fragen am Rande:

1. Gibt es da noch etwas, das überflüssig ist?

2. Wie schnell sich das Viereck bewegt, hängt ja auch von der FPS Rate ab, die ist überall wohl anders. Benutzen die Programmierer da Formeln für, damit das überall gleichschnell läuft?

DaMiNaToR

[dot]

nein.
man stoppt die zeit die zwischen dem letzten und dem aktuellen frame vergangen ist und bewegt die objekte dann immer um die entspr. zeitdifferenz weiter.

[TGGC]

Dieses Problem kann der Poster IMHO selbst lösen. Unter Umständen ist dazu eines der folgenden Hilfsmittel zu nutzen:
- Dokumentation zur benutzen API
- google
- FAQ/Suche dieses Boards
- Debugger
- geringe Mengen Gehirnschmalz

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

Disclaimer: dies ist kein direkter persönlicher Angriff.

Bye, TGGC (Reden wie die Großen)

[Sgt. Nukem]

DaMiNaToR schrieb:

2. Wie schnell sich das Viereck bewegt, hängt ja auch von der FPS Rate ab, die ist überall wohl anders. Benutzen die Programmierer da Formeln für, damit das überall gleichschnell läuft?

Was dot schon sagte. Am Anfang mit timeGetTime. Später kannst'e dann auf High Performance Counter (google) umsteigen.