Seltsame Performance-Probleme bei diversen DirectX Programmen



  • grafikkartentreiber hab ich aktualisiert, problem besteht, ausserdem sehe ich auch keinen neuen prozess beim wechseln zu windowed...

    manchmal stürzt der pc komplett ab, ohne vorwarnung, als wäre der strom weg, startet aber direkt wieder und stellt sogar die aktuelle session wieder her.
    dabei erscheint eine meldung, der hardware-treiber(ich bin im moment nicht sicher, welcher es war :P) wurde nach einem schwerwiegenden fehler zurückgesetzt.



  • Ist das nun nur im Windowed Mode lahm, oder in Windowed und Fullscreen?



  • ich glaube, wenn die caption zu sehen ist.



  • Dann kannst du da nach meinem wissen nichts gegen machen! Wer dann dein spiel, oder aplikation mit guter performanc spielen will, soll dann halt im vollbild spielen! Ich vermte das liegt an deinem treiber, kannst du die exe mal irgent wo hochladen, dann teste ich mal obs bei ir auch lahm leuft! Oder zeig mal deinen Code!



  • Es liegt definitiv nicht an einem fehlerhaften Code, da dieser aus einem Buch entnommen ist und der Fehler an vielen verschiedenen Applikationen nur bei mir auftritt!
    Um den funktionsfähigen Code zu zeigen, müsste ich schon das Projekt hochladen. Das ist ein Projekt aus einem Buch, unterteilt in mehrere Versionen. Version 1 beinhaltet lediglich den Aufbau des Windows-Fensters, erst in Version 2 wird DirectX initialisiert, wo auch der Performanceeinfall auftritt.
    Hier mal einige Ausschnitte:

    directx klasse

    class directx
    	{
    	public:
    		LPDIRECT3D9 d3d;
    		LPDIRECT3DDEVICE9 device;
    		D3DPRESENT_PARAMETERS d3dpp;
    
    		int init();
    		void adjust(int breite, int hoehe);
    	};
    
    int directx::init()
    	{
        D3DDISPLAYMODE d3ddm;
    	D3DDEVTYPE devtype;
    	D3DCAPS9 caps;
    
    	d3d = Direct3DCreate9( D3D_SDK_VERSION);
        if( !d3d)
            return 0;
    
        if( d3d->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm) < 0)
            return 0;
    
        ZeroMemory( &d3dpp, sizeof(d3dpp));
        d3dpp.Windowed = TRUE;
        d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
        d3dpp.EnableAutoDepthStencil = TRUE;
        d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
    	d3dpp.BackBufferFormat = d3ddm.Format;
    
    	if( d3d->GetDeviceCaps( D3DADAPTER_DEFAULT,  D3DDEVTYPE_HAL, &caps) < 0)
    		{
    		MessageBox( balance_window, "Kein HAL-Device - das wird langsam!", "Balance-Meldung", MB_OK | MB_ICONWARNING | MB_SETFOREGROUND);
    		devtype = D3DDEVTYPE_REF;
    		}
    	else
    		devtype = D3DDEVTYPE_HAL;
    
        if( d3d->CreateDevice( D3DADAPTER_DEFAULT, devtype, balance_window, D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dpp, &device) < 0)
            return 0;
        return 1;
    	}
    
    void directx::adjust( int breite, int hoehe)
    	{
        D3DXMATRIX proj;
    
        d3dpp.BackBufferWidth  = breite;
        d3dpp.BackBufferHeight = hoehe;
    	device->Reset( &d3dpp);
    	device->SetRenderState( D3DRS_ZENABLE, D3DZB_TRUE);
    	device->SetRenderState( D3DRS_AMBIENT, 0xffffff);
    	D3DXMatrixPerspectiveFovLH( &proj, D3DX_PI/4, ((float)breite)/hoehe, 1.0f, 500.0f);
    	device->SetTransform( D3DTS_PROJECTION, &proj);
    	}
    

    "spiel"klasse (balance ist der name)

    void balance::render()
    	{
    	int z, s;
    	D3DXMATRIX world;
    	D3DXMATRIX view;
    
    	mein_timer.start();
    
        mein_directx.device->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(255,255,255), 1.0f, 0 );
        mein_directx.device->BeginScene();
    
    	D3DXMatrixLookAtLH( &view, &hier_bin_ich, &da_gucke_ich_hin, &D3DXVECTOR3( 0.0f, 1.0f, 0.0f));
    	mein_directx.device->SetTransform( D3DTS_VIEW, &view);
    
    	for( z = 0; z < mein_spielfeld.zeilen; z++)
    		{
    		for( s = 0; s < mein_spielfeld.spalten; s++)
    			{
    		    D3DXMatrixTranslation( &world, mein_spielfeld.verschiebung_x(s), 0.0f, mein_spielfeld.verschiebung_z(z)); // Translation des objekts
    		    mein_directx.device->SetTransform( D3DTS_WORLD, &world);                  // Festlegen der Transformation
    			meine_objekte.obj[ mein_spielfeld.felder[z][s]].draw();
    			if( mein_spielfeld.hind[z][s] != NICHTS)										  // ggf. Kegel zeichnen
    				meine_objekte.hindernisse[mein_spielfeld.hind[z][s]].draw();
    			}
    		}
    
    	D3DXMatrixTranslation( &world, mein_spielfeld.verschiebung_x( mein_spielfeld.starts), 
    		                      1.0f, mein_spielfeld.verschiebung_z( mein_spielfeld.startz));
        mein_directx.device->SetTransform( D3DTS_WORLD, &world);
    	meine_objekte.kugel.draw();
    
        mein_directx.device->EndScene();
        mein_directx.device->Present( NULL, NULL, NULL, NULL);
    
    	mein_timer.stop();
    	}
    

    Main Window Handler:

    LRESULT CALLBACK balance_windowhandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
    	{
    	switch( msg) 
    		{
    	case WM_COMMAND:
    		switch( LOWORD(wParam)) 
    			{
    		case IDM_EXIT:
    			PostMessage( hWnd, WM_CLOSE, 0, 0);
    			return 0;
    			}
    		break;
    
        case WM_PAINT:
            mein_spiel.render();
            ValidateRect( hWnd, NULL);
            break;
        case WM_SIZE:
    		if( wParam != SIZE_MINIMIZED)
    			mein_directx.adjust( LOWORD(lParam), HIWORD(lParam));
            break;
    
    	case WM_DESTROY:
    
    		mein_timer.ergebnis();
    
    		PostQuitMessage( 0);
    		return 0;
    		}
        return DefWindowProc(hWnd, msg, wParam, lParam);
    	}
    

    WinMain

    int APIENTRY WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow )
    	{
    	MSG msg;
        HACCEL acc;
    	WNDCLASSEX wcx;
    
    	balance_instance = hInst;
    
    	wcx.cbSize          = sizeof( wcx); 
    	wcx.lpszClassName	= "Balance";
    	wcx.lpfnWndProc	    = balance_windowhandler;
    	wcx.style			= CS_VREDRAW | CS_HREDRAW;
    	wcx.hInstance		= hInst;
    	wcx.hIcon			= LoadIcon(hInst, MAKEINTRESOURCE( IDI_BALANCE));
    	wcx.hIconSm		    = LoadIcon(hInst, MAKEINTRESOURCE( IDI_BALANCE));
    	wcx.hCursor		    = LoadCursor(NULL, IDC_ARROW);
    	wcx.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
    	wcx.lpszMenuName	= MAKEINTRESOURCE( IDR_MENU);
    	wcx.cbClsExtra		= 0;
    	wcx.cbWndExtra		= 0;
    
    	if( !RegisterClassEx( &wcx))
    		return 0;
    
    	acc = LoadAccelerators(hInst, MAKEINTRESOURCE( IDR_ACCEL));
    
    	balance_window = CreateWindowEx(0, TEXT( "Balance"), TEXT( "Balance"), WS_OVERLAPPEDWINDOW, 
    		                                     CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInst, NULL);
    
    	if( !balance_window ) 
    		return 0;
    
    	if( !mein_spiel.init())
    		{
    		MessageBox( balance_window, "Direct3d konnte nicht initialisiert werden", "Balance-Meldung", MB_OK | MB_ICONERROR | MB_SETFOREGROUND);
    		return 0;
    		}
    
    	ShowWindow( balance_window, nCmdShow);
    
    	mein_spiel.start();
    
        while( TRUE)
    		{
            if( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE))
    			{
                if( GetMessage( &msg, NULL, 0, 0 ) == 0)
                    return 0; // Message ist WM_QUIT
    
                 if( TranslateAccelerator( balance_window, acc, &msg) == 0)
    				{
                    TranslateMessage( &msg); 
                    DispatchMessage( &msg);
    				}
    			}
    		}
        return 0;
    	}
    

    Da es sich nicht um einen Fehler im Code handelt, sondern eigentlich alles korrekt sein müsste, sind eigentlich nur die Parameter zu beachten, ob hierbei etwas auffällt.

    Ich kenn mich mit der WinApi leider nicht sonderlich aus, sprich ich habe bereits ansatzweise versucht, Vollbildmodus einzuschalten und Caption verschwinden zu lassen... Nunja.. :p



  • Das ist doch nicht der ganze code! Wenn nicht, benutzt du eien vertex Buffer?



  • Ok, hier der vollständige Code von Balance.cpp(Und ja ich benutze einen Vertex-Buffer):

    # include <stdio.h>
    # include <stdarg.h>
    # include <windows.h>
    # include <commctrl.h>
    # include <d3dx9.h>
    # include <dinput.h>
    # include "d3dfont.h"
    
    # include "resource.h"
    
    HINSTANCE balance_instance;
    HWND balance_window;
    
    // V2 Beginn
    
    # include <time.h>
    
    class timer
    	{
    	private:
    		unsigned int ticks;
    		unsigned int calls;
    		unsigned int t;
    	public:
    		timer() {calls = 0; ticks = 0;}
    		void start() { t = clock();}
    		void stop() { ticks += clock() - t; calls++;}
    		void ergebnis();
    	};
    
    void timer::ergebnis()
    	{
    	char buf[128];
    	int msecs;
    
    	msecs = ticks * 1000 / CLOCKS_PER_SEC;
    	sprintf( buf, "Gesamtzeit:      %d ms\rAnzahl Aufrufe: %d\rZeit pro Aufruf: %d ms", msecs, calls, calls ? msecs/calls : 0);
    	MessageBox( balance_window, buf, "Balance-Meldung", MB_OK | MB_ICONINFORMATION | MB_SETFOREGROUND);
    	}
    
    timer mein_timer;
    
    class directx
    	{
    	public:
    		LPDIRECT3D9 d3d;
    		LPDIRECT3DDEVICE9 device;
    		D3DPRESENT_PARAMETERS d3dpp;
    
    		int init();
    		void adjust(int breite, int hoehe);
    	};
    
    int directx::init()
    	{
        D3DDISPLAYMODE d3ddm;
    	D3DDEVTYPE devtype;
    	D3DCAPS9 caps;
    
    	d3d = Direct3DCreate9( D3D_SDK_VERSION);
        if( !d3d)
            return 0;
    
        if( d3d->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm) < 0)
            return 0;
    
        ZeroMemory( &d3dpp, sizeof(d3dpp));
        d3dpp.Windowed = TRUE;
        d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
        d3dpp.EnableAutoDepthStencil = TRUE;
        d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
    	d3dpp.BackBufferFormat = d3ddm.Format;
    
    	if( d3d->GetDeviceCaps( D3DADAPTER_DEFAULT,  D3DDEVTYPE_HAL, &caps) < 0)
    		{
    		MessageBox( balance_window, "Kein HAL-Device - das wird langsam!", "Balance-Meldung", MB_OK | MB_ICONWARNING | MB_SETFOREGROUND);
    		devtype = D3DDEVTYPE_REF;
    		}
    	else
    		devtype = D3DDEVTYPE_HAL;
    
        if( d3d->CreateDevice( D3DADAPTER_DEFAULT, devtype, balance_window, D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dpp, &device) < 0)
            return 0;
        return 1;
    	}
    
    void directx::adjust( int breite, int hoehe)
    	{
        D3DXMATRIX proj;
    
        d3dpp.BackBufferWidth  = breite;
        d3dpp.BackBufferHeight = hoehe;
    	device->Reset( &d3dpp);
    	device->SetRenderState( D3DRS_ZENABLE, D3DZB_TRUE);
    	device->SetRenderState( D3DRS_AMBIENT, 0xffffff);
    	D3DXMatrixPerspectiveFovLH( &proj, D3DX_PI/4, ((float)breite)/hoehe, 1.0f, 500.0f);
    	device->SetTransform( D3DTS_PROJECTION, &proj);
    	}
    
    directx mein_directx;
    
    class objekt
    	{
    	private:
    		LPD3DXMESH mesh;
    		D3DMATERIAL9 *materialien;
    		DWORD anz_mat;
    		LPDIRECT3DTEXTURE9 *texturen;
    	public:
    		objekt();
    		void load( char *xfile);
    		void draw();
    		~objekt();
    	};
    
    objekt::objekt()
    	{
    	mesh = NULL;
    	materialien = NULL;
    	anz_mat = 0;
    	texturen = NULL;
    	}
    
    objekt::~objekt()
    	{
    	unsigned int i;
    
        if( materialien) 
            delete[] materialien;
    
        if( texturen)
    		{
            for( i = 0; i < anz_mat; i++ )
    			{
                if( texturen[i])
                    texturen[i]->Release();
    			}
            delete[] texturen;
    		}
        if( mesh)
            mesh->Release();   
    	}
    
    void objekt::load( char *xfile)
    	{
        LPD3DXBUFFER buf;
    	D3DXMATERIAL* mat; 
    	DWORD i;
    
        D3DXLoadMeshFromX( xfile, D3DXMESH_SYSTEMMEM, mein_directx.device, NULL, &buf, NULL, &anz_mat, &mesh);
    
    	mat = (D3DXMATERIAL*)buf->GetBufferPointer();
        materialien = new D3DMATERIAL9[anz_mat];
        texturen  = new LPDIRECT3DTEXTURE9[anz_mat];
    
        for( i=0; i<anz_mat; i++)
    		{
            materialien[i] = mat[i].MatD3D;
    		materialien[i].Ambient.r = 1.0f;
    		materialien[i].Ambient.g = 1.0f;
    		materialien[i].Ambient.b = 1.0f;
    		if( D3DXCreateTextureFromFile( mein_directx.device, mat[i].pTextureFilename, &texturen[i]) < 0) 
                texturen[i] = NULL;
    		}
        buf->Release();
        }
    
    void objekt::draw()
    	{
    	unsigned int i;
    
    	for( i=0; i < anz_mat; i++ )
    		{
    		mein_directx.device->SetMaterial( &materialien[i]);
            mein_directx.device->SetTexture( 0, texturen[i]);
    		mesh->DrawSubset( i);
    
    		}
    	}
    
    # define WASSER  0
    # define HOLZ    1
    # define STEIN   2
    # define GRAS    3
    # define ZIEL    4
    
    # define NICHTS -1
    # define KEGEL   0
    # define BUMPER  1
    # define MARKIERUNG 2
    
    class objekte
    	{
    	public:
    		objekt kugel;
    		objekt rahmen;
    		objekt obj[5];
    		objekt hindernisse[3];
    		void lade_objekte();
    	};
    
    void objekte::lade_objekte()
    	{
    	obj[WASSER].load( "Wasser.x");
    	obj[HOLZ].load( "Holz.x");
    	obj[STEIN].load( "Stein.x");
    	obj[GRAS].load( "Gras.x");
    	obj[ZIEL].load( "Ziel.x");
    	hindernisse[KEGEL].load( "Kegel.x");
    	hindernisse[BUMPER].load( "Bumper.x");
    	hindernisse[MARKIERUNG].load( "Markierung.x");
    	kugel.load( "Kugel.x");
    	rahmen.load( "Rahmen.x");
    	}
    
    objekte meine_objekte;
    
    class spielfeld
    	{
    	private:
    		int save_hind[100][100];
    	public:
    		int zeilen;				// Anzahl Zeilen des Spielfelds
    		int spalten;			// Anzahl Spalten des Spielfeldes
    		int anzahl_markierungen;
    		int startz;				// Startzeile der Kugel
    		int starts;             // Startspalte der Kugel
    		int felder[100][100];   // Untergrund des Spielfeldes
    		int hind[100][100];	    // Hindernisse auf dem Spielfeld
    
    		spielfeld();            // Konstruktor
    		void init( int z, int s, int mode); // Leeres oder zufaellig besetztes Spielfeld anlegen
    		float verschiebung_x( int s) {return 4.0f*s - 2.0f*spalten + 2.0f;}
    		float verschiebung_z( int z) {return 4.0f*z - 2.0f*zeilen + 2.0f;}
    		void save();
    		void reload();
    	};
    
    void spielfeld::init( int z, int s, int mode)
    	{
    	if((z > 100) || ( z < 1) || ( s > 100) || ( s < 1))
    		return;
    
    	zeilen = z;
    	spalten = s;
    	anzahl_markierungen = 0;
    
    	srand( timeGetTime());
    	for( z = 0; z < zeilen; z++)
    		{
    		for( s = 0; s < spalten; s++)
    			{
    			felder[z][s] = mode ? rand()%5 : HOLZ;
    			if( mode && (felder[z][s] != 0) && (felder[z][s] != 4))
    				hind[z][s] = rand()%4 - 1;
    			else
    				hind[z][s] = NICHTS;
    			if( hind[z][s] == MARKIERUNG)
    				anzahl_markierungen++;
    			}
    		}
    	felder[0][0] = HOLZ;
    	if( hind[0][0] == MARKIERUNG)
    		anzahl_markierungen--;
    	hind[0][0] = NICHTS;
    	startz = 0;
    	starts = 0;
    	}
    
    void spielfeld::save()
    	{
    	int z, s;
    
    	anzahl_markierungen = 0;
    	for( z = 0; z < zeilen; z++)
    		{
    		for( s = 0; s < spalten; s++)
    			{
    			save_hind[z][s] = hind[z][s];
    			if( hind[z][s] == MARKIERUNG)
    				anzahl_markierungen++;
    			}
    		}
    	}
    
    void spielfeld::reload()
    	{
    	int z, s;
    
    	anzahl_markierungen = 0;
    	for( z = 0; z < zeilen; z++)
    		{
    		for( s = 0; s < spalten; s++)
    			{
    			hind[z][s] = save_hind[z][s];
    			if( save_hind[z][s] == MARKIERUNG)
    				anzahl_markierungen++;
    			}
    		}
    	}
    
    spielfeld::spielfeld()
    	{
    	init( 8, 8, 1);
    	save();
    	}
    
    spielfeld mein_spielfeld;
    
    class balance
    	{
    	private:
    		D3DXVECTOR3 hier_bin_ich;
    		D3DXVECTOR3 da_gucke_ich_hin;
    	public:
    		int init();
    		void start();
    		void render();
    	};
    
    void balance::start()
    	{
    	mein_spielfeld.reload();
    	hier_bin_ich = D3DXVECTOR3( 0.0f, 3.5f*mein_spielfeld.spalten, -3.5f*mein_spielfeld.spalten);
    	da_gucke_ich_hin = D3DXVECTOR3( 0.0f, 0.0f, 0.0f);
    	}
    
    int balance::init()
    	{
    	if( !mein_directx.init())
    		return 0;
    	meine_objekte.lade_objekte();
    	return 1;
    	}
    
    void balance::render()
    	{
    	int z, s;
    	D3DXMATRIX world;
    	D3DXMATRIX view;
    
    	mein_timer.start();
    
        mein_directx.device->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(255,255,255), 1.0f, 0 );
        mein_directx.device->BeginScene();
    
    	D3DXMatrixLookAtLH( &view, &hier_bin_ich, &da_gucke_ich_hin, &D3DXVECTOR3( 0.0f, 1.0f, 0.0f));
    	mein_directx.device->SetTransform( D3DTS_VIEW, &view);
    
    	for( z = 0; z < mein_spielfeld.zeilen; z++)
    		{
    		for( s = 0; s < mein_spielfeld.spalten; s++)
    			{
    		    D3DXMatrixTranslation( &world, mein_spielfeld.verschiebung_x(s), 0.0f, mein_spielfeld.verschiebung_z(z)); // Translation des objekts
    		    mein_directx.device->SetTransform( D3DTS_WORLD, &world);                  // Festlegen der Transformation
    			meine_objekte.obj[ mein_spielfeld.felder[z][s]].draw();
    			if( mein_spielfeld.hind[z][s] != NICHTS)										  // ggf. Kegel zeichnen
    				meine_objekte.hindernisse[mein_spielfeld.hind[z][s]].draw();
    			}
    		}
    
    	D3DXMatrixTranslation( &world, mein_spielfeld.verschiebung_x( mein_spielfeld.starts), 
    		                      1.0f, mein_spielfeld.verschiebung_z( mein_spielfeld.startz));
        mein_directx.device->SetTransform( D3DTS_WORLD, &world);
    	meine_objekte.kugel.draw();
    
        mein_directx.device->EndScene();
        mein_directx.device->Present( NULL, NULL, NULL, NULL);
    
    	mein_timer.stop();
    	}
    
    balance mein_spiel;
    
    // V02 Ende
    
    LRESULT CALLBACK balance_windowhandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
    	{
    	switch( msg) 
    		{
    	case WM_COMMAND:
    		switch( LOWORD(wParam)) 
    			{
    		case IDM_EXIT:
    			PostMessage( hWnd, WM_CLOSE, 0, 0);
    			return 0;
    			}
    		break;
    // V2 Beginn
        case WM_PAINT:
            mein_spiel.render();
            ValidateRect( hWnd, NULL);
            break;
        case WM_SIZE:
    		if( wParam != SIZE_MINIMIZED)
    			mein_directx.adjust( LOWORD(lParam), HIWORD(lParam));
            break;
    // V2 Ende
    	case WM_DESTROY:
    // V2 Beginn
    		mein_timer.ergebnis();
    // V2 Ende
    		PostQuitMessage( 0);
    		return 0;
    		}
        return DefWindowProc(hWnd, msg, wParam, lParam);
    	}
    
    int APIENTRY WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow )
    	{
    	MSG msg;
        HACCEL acc;
    	WNDCLASSEX wcx;
    
    	balance_instance = hInst;
    
    	wcx.cbSize          = sizeof( wcx); 
    	wcx.lpszClassName	= "Balance";
    	wcx.lpfnWndProc	    = balance_windowhandler;
    	wcx.style			= CS_VREDRAW | CS_HREDRAW;
    	wcx.hInstance		= hInst;
    	wcx.hIcon			= LoadIcon(hInst, MAKEINTRESOURCE( IDI_BALANCE));
    	wcx.hIconSm		    = LoadIcon(hInst, MAKEINTRESOURCE( IDI_BALANCE));
    	wcx.hCursor		    = LoadCursor(NULL, IDC_ARROW);
    	wcx.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
    	wcx.lpszMenuName	= MAKEINTRESOURCE( IDR_MENU);
    	wcx.cbClsExtra		= 0;
    	wcx.cbWndExtra		= 0;
    
    	if( !RegisterClassEx( &wcx))
    		return 0;
    
    	acc = LoadAccelerators(hInst, MAKEINTRESOURCE( IDR_ACCEL));
    
    	balance_window = CreateWindowEx(0, TEXT( "Balance"), TEXT( "Balance"), WS_OVERLAPPEDWINDOW, 
    		                                     CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInst, NULL);
    
    	if( !balance_window ) 
    		return 0;
    
    // V2 Beginn
    	if( !mein_spiel.init())
    		{
    		MessageBox( balance_window, "Direct3d konnte nicht initialisiert werden", "Balance-Meldung", MB_OK | MB_ICONERROR | MB_SETFOREGROUND);
    		return 0;
    		}
    // V2 Ende
    
    	ShowWindow( balance_window, nCmdShow);
    // V2 Beginn
    	mein_spiel.start();
    // V2 Ende
        while( TRUE)
    		{
            if( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE))
    			{
                if( GetMessage( &msg, NULL, 0, 0 ) == 0)
                    return 0; // Message ist WM_QUIT
    
                 if( TranslateAccelerator( balance_window, acc, &msg) == 0)
    				{
                    TranslateMessage( &msg); 
                    DispatchMessage( &msg);
    				}
    			}
    		}
        return 0;
    	}
    


  • Dann leigt das Problem auf der Hand! Ich selber hatte auch immer das Problem, und wusste nie warum! Es liegt am VertexBuffer! Das Problem ist einfach das deine gpu die Vertices schneller verarbeiten kann als deine cpu! Das problem ist weg, wenn das Programm größer ist, und auch mehr zum rechnen in anspruch nimmt, evtl noch mit Shadern arbeitest etc! Das Problem legt sich später dann ganz automatisch, keine panic^^ Das Problem ist bei OpenGL und DX, vieleicht wird es irgent wann mal einen treiber geben, amit man dies problem nicht mehr hat xD Du solltest auf jeden fall aber weiterhin VertexBuffer verwenden, da sie um einiges schneller sind, als auf die herkömmliche art, auch wenn das im moment noch nicht o scheint! Mach daraus mal etwas größeres, mach mehr rechnungen etc, dann wirst du sehen das es nicht mehr stottert 🙂



  • Wäre schön, wenn das die Lösung wäre...
    Leider benutzen andere Programme(GameMaker) keinen Vertex Buffer(->2d ), oder komplexere Anwendungen mit Benutzung der Irrlicht-Engine, die beide trotzdem dieses Problem haben. 😞
    Wie kann ich das verstehn, dass bei einfachen Anwendungen alles grafische über die CPU statt der GPU berechnet wird oder was?! 😮



  • Ne, das staut sich einfach nur auf!


Anmelden zum Antworten