Discussion :

[Hidekii]

Bonsoir,

Voila, je ne comprends pas pourquoi, mais quand je lance une appli du sdk directx (ex : Enhanced Mesh), je fais plus de 2000fps en fenetré.
Alors qu'avec mes petites applis, j'atteints peniblement les 150fps en fenetré (même avec une scène vide). C'est très frustrant
(j'ai une GeForce 4 Ti 4600)
Je ne comprends vraiment pas ce que le SDK fait de plus que moi.....
J'ai relu tout leur code, et je ne vois pas.

Pour info, je fais bien :

d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;

...pour enlever le VSync.

Voila mon code d'initialisation (au cas ou) :
(il gere le mode fenetré et plein ecran)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
	// Création de l'objet Direct3D
	lpD3D = Direct3DCreate9( D3D_SDK_VERSION );
	if(!lpD3D)
	{
		MessageBox(hWnd, "Direct3DCreate", "Erreur...", MB_OK);
		return false;
	}
 
	// On prépare le format
	memset(&d3dpp, 0, sizeof(d3dpp));
 
	d3dpp.hDeviceWindow = hWnd;
 
	// Si l'application est en mode fenêtré
	if(bWindowed)
	{
		d3dpp.Windowed = true;
		d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;//D3DPRESENT_INTERVAL_DEFAULT;
	    D3DDISPLAYMODE d3ddm;
 
		// On récupère les infos sur l'affichage courant
		if(FAILED(lpD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm )))
		{
			MessageBox(hWnd, "GetAdapterDisplayMode", "Erreur...", MB_OK);
			return false;
		}
 
		Format = d3dpp.BackBufferFormat = d3ddm.Format;
	}
 
	// Si l'application est en plein écran
	else
	{
		d3dpp.Windowed = false;
 
		// On cherche un format compatible avec celui demandé
		switch(wDepth)
		{
			case 32:
 
				TryFormat(D3DFMT_A8R8G8B8);
				TryFormat(D3DFMT_X8R8G8B8);
 
			case 16:
 
				TryFormat(D3DFMT_R5G6B5);
				TryFormat(D3DFMT_X1R5G5B5);
 
			default:
 
				Format = D3DFMT_UNKNOWN;
		}
 
		if(Format == D3DFMT_UNKNOWN)
		{
			MessageBox(hWnd, "D3DFMT_UNKNOWN", "Erreur...", MB_OK);
			return false;
		}
 
		d3dpp.BackBufferFormat					= Format;
		d3dpp.FullScreen_RefreshRateInHz		= D3DPRESENT_RATE_DEFAULT;
		d3dpp.PresentationInterval				= D3DPRESENT_INTERVAL_DEFAULT;
	}
 
	d3dpp.BackBufferWidth	= Width;
	d3dpp.BackBufferHeight	= Height;
	d3dpp.SwapEffect		= D3DSWAPEFFECT_DISCARD;
 
	// Cherche un format de zBuffer compatible avec le mode choisi
	zFormat = D3DFMT_UNKNOWN;
 
	if(TestDepth(D3DFMT_D32))
		zFormat = D3DFMT_D32;
	else if(TestDepth(D3DFMT_D24S8)) 
		zFormat = D3DFMT_D24S8;
	else if(TestDepth(D3DFMT_D24X4S4))
		zFormat = D3DFMT_D24X4S4;
	else if(TestDepth(D3DFMT_D24X8)) 
		zFormat = D3DFMT_D24X8;
	else if(TestDepth(D3DFMT_D16))
		zFormat = D3DFMT_D16;
	else if(TestDepth(D3DFMT_D15S1))
		zFormat = D3DFMT_D15S1;
	else if(TestDepth(D3DFMT_D16_LOCKABLE))
		zFormat = D3DFMT_D16_LOCKABLE;
 
 
	if(zFormat != D3DFMT_UNKNOWN)
	{
		d3dpp.EnableAutoDepthStencil = true;
		d3dpp.AutoDepthStencilFormat = zFormat;
	}
 
	d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
 
	// Teste les capacités de la carte graphique
	if(FAILED(lpD3D->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &d3dCaps)))
	{
		MessageBox(hWnd, "GetDeviceCaps", "Erreur...", MB_OK);
		return false;
	}
 
	DWORD dwBehaviorFlags = 0;
 
	if( d3dCaps.VertexProcessingCaps != 0 )
		dwBehaviorFlags |= D3DCREATE_HARDWARE_VERTEXPROCESSING;
	else
		dwBehaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
 
 
	// On créé le Device
	if(FAILED(hRes=lpD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, dwBehaviorFlags, &d3dpp, &lpDevice)))
	{
		MessageBox(hWnd, "CreateDevice", "Erreur...", MB_OK);
		return false;
	}
 
 
	D3DVIEWPORT9 d3dViewPort;
 
	d3dViewPort.X = 0;
	d3dViewPort.Y = 0;
	d3dViewPort.Width = wWidth;
	d3dViewPort.Height = wHeight;
	d3dViewPort.MinZ = 0.0f;
	d3dViewPort.MaxZ = 1.0f;
 
	if(FAILED(lpDevice->SetViewport(&d3dViewPort)))
	{
		MessageBox(hWnd, "SetViewport", "Erreur...", MB_OK);
		return false;
	}

Franchement, si quelqu'un me trouve la solution pour que j'affiche 2000fps avec une scene vierge, je tire mon chapeau
(meme avec un PURE DEVICE, les perfs augmentent à peine)

[Laurent Gomila]

Peut-etre la façon dont tu geres ta boucle d'affichage ? Tu peux nous montrer le reste du code ?

[Hidekii]

Voila la boucle d'affichage :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
	bool flag_H = false;	// Flag qui détermine quel timer est utilisé
 
	// On initialise l'horloge
	flag_H = InitHorloge();
	InitScene();
 
	// On reçoit et traite les messages Windows
	BOOL ReceptionMsg;
	MSG Msg;
	PeekMessage(&Msg, NULL, 0, 0, PM_NOREMOVE);
 
	ShowCursor(Windowed);
 
	while(Msg.message != WM_QUIT)
	{
 
			ReceptionMsg = PeekMessage(&Msg, NULL, 0, 0, PM_REMOVE);
			if(ReceptionMsg)
			{
				TranslateMessage(&Msg);
				DispatchMessage(&Msg);
			}
 
			else
			{
				if(CheckDevice())
				{
					// Mise à jour des données DInput
					Input->ReadUserInput();
 
					// Mise à jour des vars de temps
					MajHorloge(flag_H);
 
					// Effectue les déplacements éventuels
					Mouvements(time_elapsed);
 
					// Rendu
					Render();
				}
			}
		}
 
 
	return 1;

Et la gestion des messages :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
LRESULT CALLBACK WindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
    switch(uMsg)
	{
 
		case WM_DESTROY:
			SafeDelete(D3D);
			PostQuitMessage(0);
			break;
 
 
		case WM_SIZE:
			if(D3D)
			{
				if (SIZE_MINIMIZED == wParam)
				{
					D3D->Desactiver();
 
					D3D->Maximized = false;
					D3D->Minimized = true;
				}
				else if (SIZE_MAXIMIZED == wParam)
				{
					if (D3D->Minimized)
						D3D->Activer();
 
					D3D->Maximized = true;
					D3D->Minimized = false;
					D3D->TraiterChangementTailleFenetre();
				}
				else if (SIZE_RESTORED == wParam)
				{
					if(D3D->Maximized)
					{
						D3D->Maximized = false;
						D3D->TraiterChangementTailleFenetre();
					}
					else if (D3D->Minimized)
					{
						D3D->Minimized = false;
						D3D->Activer();
						D3D->TraiterChangementTailleFenetre();
					}
				}
			}
			break;
 
 
		case WM_KEYDOWN:
			if(D3D)
			{
				switch(wParam)
				{
				case VK_ESCAPE:
					SafeDelete(D3D);
					PostQuitMessage(0);
					break;
 
				case VK_F2:
					// On libère les ressources (scene)
					D3D->FreeResources();
					// On restaure le device
					D3D->ResetDisplayMode(true);
					// On restaure les ressources (scene)
					D3D->RestoreResources();
					break;
 
				case VK_F3:
					// On libère les ressources (scene)
					D3D->FreeResources();
					// On restaure le device
					D3D->ResetDisplayMode(false);
					// On restaure les ressources (scene)
					D3D->RestoreResources();
					break;
 
				case VK_F5:
					D3D->Desactiver();
					break;
 
				case VK_F6:
					D3D->Activer();
					break;
 
				case VK_F12:
					D3D->ScreenShot("ScreenShot.jpg", D3DXIFF_JPG);
					break;
				}
			}
			break;
 
 
		case WM_CLOSE:
			SafeDelete(D3D);
			PostQuitMessage(0);
			break;
 
 
		case WM_ACTIVATEAPP:
			if(D3D)
			{
				if(wParam) 
					D3D->Activer();
				else 
					D3D->Desactiver();
			}
			break;
 
 
	    case WM_ENTERSIZEMOVE:
			if(D3D)
				D3D->Desactiver();
			break;
 
 
		case WM_EXITSIZEMOVE:
			if(D3D)
			{
				D3D->Activer();
				D3D->TraiterChangementTailleFenetre();			
			}
			break;
 
 
	default:
		return DefWindowProc(hWnd, uMsg, wParam, lParam);
		break;
	}
 
	return 0;
}

Au pire, je ferai un petit programme complet (scene vide) que je posterai.
Je ne comprends vraiment pas cet écart de perfs.

En tout cas, merci

A++

[Bob.Killer]

mais ds le SDK ils ont tt optimisé et on sait pas comment ils comptent leurs frames Moi aussi j'atteinds pas les 2000fps avec ma classe qui gère les optimized meshs ! pourtant y a rien à afficher lol

[Laurent Gomila]

Au pire, je ferai un petit programme complet (scene vide) que je posterai

Ca c'est une bonne idée

Parce que là a priori il n'y a rien de louche dans ton code.

[Hidekii]

Ok je vais faire ça ce soir.

Sinon, pour le code super optimisé de microsoft, j'y crois pas trop.
Si tu as regardé leur code, tu verras qu'il n'y a rien d'exceptionnel.

Sinon, j'ai trouvé un truc qui me pousse à me poser des questions :

Frames per Second

When HelloTeapot runs, you will most likely see the frames per second hovering
around the mid-90's. Direct3DHost has a ProcessingBehavior property that when
set to ConserveCPU (the default setting), it will only use up as much CPU
overhead as is required to keep the frame rate in around 90-100 fps ballpark.
Try setting ProcessingBehavior to FullThrottle; you should see FPS go up along
with your CPU utilization, but no actual visual difference in rendering the
spinning teapot.

Cela voudrait dire que DirectX assure un minimum de 90-100Fps tout simplement ? Ce serait alors un problème de gestion priorité de processus ? Peut etre que microsoft a inclus dans son code un appel qui change cette priorité....
Je vais fouiller dans cette direction.
Sinon, j'écris le petit prog ce soir.

Merci
A+

[Hidekii]

Voila un mini programme.
Bon, c'est pas super propre, mais j'ai fait le minimum.
Il y a une initialisation en fenetré, et un rendu vide (avec compteur fps)
Avec ça, je fais 130 images/s maxi en 1024*768 fenetré (32bits)
En créant un projet directx 9 vide sous visual studio (minimum d'options, scene vide, meme résolution), j'obtiens + de 800fps....

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
 
#define WIN32_LEAN_AND_MEAN
 
#include <d3dx9.h>
#include <windows.h>
#include <windowsx.h>
#include <mmsystem.h>
 
 
static char NomFen[]		= "Ma classe";
static char CaptionFen[]	= "Direct3D (DX9)";
 
LPDIRECT3D9 lpD3D;			// Interface Direct3D
LPDIRECT3DDEVICE9 lpDevice;	// Device Direct3D
D3DPRESENT_PARAMETERS d3dpp;// Structure contenant les paramètres du Device Direct3D
D3DCAPS9 d3dCaps;			// Structure contenant les capacités de la carte GFX
D3DFORMAT zFormat;
D3DFORMAT Format;
 
int fpsCourant;				// Variable du compteur FPS
int fpsAncien;
int fpsCpt;
LONGLONG cur_time;			// Temps courant
LONGLONG last_time;			// date du dernier cycle
 
float time_elapsed;			// temps écoulé depuis le dernier cycle
float time_scale;			// facteur d'accélération du temps
 
 
 
 
 
 
//////////////////////////////////////////////////////////////////////////
//	TEST DEPTH															//
//////////////////////////////////////////////////////////////////////////
// - Verifie si le format graphique demandé est supporté par le device	//
//////////////////////////////////////////////////////////////////////////
 
bool TestDepth(D3DFORMAT xFormat)
{
	if(lpD3D)
	{
		if(lpD3D->CheckDeviceFormat(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, Format, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, xFormat) != D3D_OK)
			return false;
 
		if(lpD3D->CheckDepthStencilMatch(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, Format, Format, xFormat) != D3D_OK)
			return false;
	}
 
	return true;
}
 
 
 
 
 
//////////////////////////////////////////////////////////////////////////
//	TEST FORMAT															//
//////////////////////////////////////////////////////////////////////////
// - Verifie si le format graphique demandé est supporté par le device	//
//////////////////////////////////////////////////////////////////////////
 
bool TestFormat(D3DFORMAT xFormat)
{
	if(lpD3D)
	{
		if(lpD3D->CheckDeviceType(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, xFormat, xFormat, false) == D3D_OK)
			return true;
	}
	return false;
}
 
 
 
 
 
 
 
void DrawText(char * Text, int x, int y)
{
	LPD3DXFONT pD3DXFont;
	D3DXFONT_DESC pD3DXDesc;
 
	ZeroMemory (&pD3DXDesc, sizeof(D3DXFONT_DESC));
    pD3DXDesc.Height = 20;
    pD3DXDesc.Weight = 700;
 
	if(FAILED(D3DXCreateFontIndirect(lpDevice, &pD3DXDesc, &pD3DXFont)))
		return;
 
    RECT rct;
    rct.left = x;
    rct.top = y;
    rct.right = 640;
	rct.bottom = 480;
 
    // Trucs a tracer:
    pD3DXFont->DrawText(NULL, Text, -1, &rct, DT_LEFT, D3DCOLOR_XRGB(255, 255, 255));
	pD3DXFont->Release();
}
 
 
 
 
 
void CountFPS()
{
	// On calcule le nombre d'images afficher par seconde :
    if (GetTickCount() - fpsAncien >= 1000)
	{
		fpsCourant = fpsCpt;
        fpsCpt = 0;
        fpsAncien = GetTickCount();
	}
 
    fpsCpt = fpsCpt + 1;
 
	// Affichage du texte
	DrawText("FPS = ", 2, 1);
 
	char * FPS = new char[10];
	itoa(fpsCourant,FPS,10);
	DrawText(FPS, 58, 1);
}
 
 
 
 
 
LRESULT CALLBACK WindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
    switch(uMsg)
	{
 
		case WM_DESTROY:
			//
			lpDevice->Release();
			lpD3D->Release();
			PostQuitMessage(0);
			break;
 
 
 
 
		case WM_KEYDOWN:
				switch(wParam)
				{
				case VK_ESCAPE:
					lpDevice->Release();
					lpD3D->Release();
					PostQuitMessage(0);
					break;
				}
			break;
 
 
		case WM_CLOSE:
			lpDevice->Release();
			lpD3D->Release();
			PostQuitMessage(0);
			break;
 
 
 
	default:
		return DefWindowProc(hWnd, uMsg, wParam, lParam);
		break;
	}
 
	return 0;
}
 
 
 
 
 
void Render()
{
	lpDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0);
    lpDevice->BeginScene();
 
	CountFPS();
 
	lpDevice->EndScene();
    lpDevice->Present( NULL, NULL, NULL, NULL );
}
 
 
 
 
 
bool InitHorloge()
{
	// Determine quel timer sera utilisé
	if(QueryPerformanceFrequency((LARGE_INTEGER *) &cur_time))
	{
		time_scale = 1.0f / cur_time;
		QueryPerformanceCounter((LARGE_INTEGER *) &last_time);
		return true;
	}
 
	else
	{
		time_scale = 0.001f;
		last_time = timeGetTime();
		return false;
	}
}
 
 
 
 
//////////////////////////////////////////////////////////////////////////
//	MAJ DE L'HORLOGE													//
//////////////////////////////////////////////////////////////////////////
// - Calcule le temps écoulé entre 2 rendus	(= entre 2 cycles)			//
//////////////////////////////////////////////////////////////////////////
 
void MajHorloge(bool Flag)
{
	// On récupère l'heure (2 méthodes =/=)
	if(Flag)
		QueryPerformanceCounter((LARGE_INTEGER *) &cur_time);
	else
		cur_time = timeGetTime();
 
	// Calcul du temps écoulé depuis le dernier cycle
	time_elapsed = (cur_time - last_time) * time_scale;
 
	// Sauvegarde date du cycle courant
	last_time = cur_time;
}
 
 
 
 
 
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
	// Initialisation des données membres
	lpD3D		= NULL;
	lpDevice	= NULL;
 
	WNDCLASS wc;
 
	// Classe window
	wc.style			= CS_HREDRAW | CS_VREDRAW;
	wc.lpfnWndProc		= (WNDPROC) WindowProc;
	wc.cbClsExtra		= 0;
	wc.cbWndExtra		= sizeof(DWORD);
	wc.hInstance		= hInstance;
	wc.hIcon			= NULL;
	wc.hCursor			= LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground	= (HBRUSH) GetStockObject(WHITE_BRUSH);
	wc.lpszMenuName		= NULL;
	wc.lpszClassName	= NomFen;
 
	RegisterClass(&wc);
 
	// Dimensions de l'écran
	int ScreenWidth		= GetSystemMetrics(SM_CXSCREEN);
	int ScreenHeight	= GetSystemMetrics(SM_CYSCREEN);
 
	HWND hWnd = CreateWindow(NomFen, CaptionFen, WS_OVERLAPPEDWINDOW, 0, 0, ScreenWidth, ScreenHeight, NULL, NULL, hInstance, NULL);
 
	if(!hWnd)
	{
		MessageBox(hWnd, "CreateWindow", "Erreur...", MB_OK);
		return 0;
	}
 
	// On place la fenêtre et on l'affiche
	SetWindowPos(hWnd, HWND_TOP, 0, 20, 1024, 768, SWP_SHOWWINDOW);
 
 
 
	// Création de l'objet Direct3D
	lpD3D = Direct3DCreate9( D3D_SDK_VERSION );
	if(!lpD3D)
	{
		MessageBox(hWnd, "Direct3DCreate", "Erreur...", MB_OK);
		return false;
	}
 
	// On prépare le format
	memset(&d3dpp, 0, sizeof(d3dpp));
 
	d3dpp.hDeviceWindow = hWnd;
 
	// l'application est en mode fenêtré
 
	d3dpp.Windowed = true;
	d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;//D3DPRESENT_INTERVAL_DEFAULT;
    D3DDISPLAYMODE d3ddm;
 
	// On récupère les infos sur l'affichage courant
	if(FAILED(lpD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm )))
	{
		MessageBox(hWnd, "GetAdapterDisplayMode", "Erreur...", MB_OK);
		return false;
	}
 
	Format = d3dpp.BackBufferFormat = d3ddm.Format;
 
	d3dpp.BackBufferWidth	= 1024;
	d3dpp.BackBufferHeight	= 768;
	d3dpp.SwapEffect		= D3DSWAPEFFECT_DISCARD;
 
	// Cherche un format de zBuffer compatible avec le mode choisi
	zFormat = D3DFMT_UNKNOWN;
 
	if(TestDepth(D3DFMT_D32))
		zFormat = D3DFMT_D32;
	else if(TestDepth(D3DFMT_D24S8)) 
		zFormat = D3DFMT_D24S8;
	else if(TestDepth(D3DFMT_D24X4S4))
		zFormat = D3DFMT_D24X4S4;
	else if(TestDepth(D3DFMT_D24X8)) 
		zFormat = D3DFMT_D24X8;
	else if(TestDepth(D3DFMT_D16))
		zFormat = D3DFMT_D16;
	else if(TestDepth(D3DFMT_D15S1))
		zFormat = D3DFMT_D15S1;
	else if(TestDepth(D3DFMT_D16_LOCKABLE))
		zFormat = D3DFMT_D16_LOCKABLE;
 
 
	if(zFormat != D3DFMT_UNKNOWN)
	{
		d3dpp.EnableAutoDepthStencil = true;
		d3dpp.AutoDepthStencilFormat = zFormat;
	}
 
	d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
 
	// Teste les capacités de la carte graphique
	if(FAILED(lpD3D->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &d3dCaps)))
	{
		MessageBox(hWnd, "GetDeviceCaps", "Erreur...", MB_OK);
		return false;
	}
 
	DWORD dwBehaviorFlags = 0;
 
	if( d3dCaps.VertexProcessingCaps != 0 )
		dwBehaviorFlags |= D3DCREATE_HARDWARE_VERTEXPROCESSING;
	else
		dwBehaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
 
 
	// On créé le Device
	if(FAILED(lpD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, dwBehaviorFlags, &d3dpp, &lpDevice)))
	{
		MessageBox(hWnd, "CreateDevice", "Erreur...", MB_OK);
		return false;
	}
 
 
	D3DVIEWPORT9 d3dViewPort;
 
	d3dViewPort.X = 0;
	d3dViewPort.Y = 0;
	d3dViewPort.Width = 1024;
	d3dViewPort.Height = 768;
	d3dViewPort.MinZ = 0.0f;
	d3dViewPort.MaxZ = 1.0f;
 
	if(FAILED(lpDevice->SetViewport(&d3dViewPort)))
	{
		MessageBox(hWnd, "SetViewport", "Erreur...", MB_OK);
		return false;
	}
 
 
 
 
	bool flag_H = false;	// Flag qui détermine quel timer est utilisé
 
	// On initialise l'horloge
	flag_H = InitHorloge();
 
 
	// On reçoit et traite les messages Windows
	BOOL ReceptionMsg;
	MSG Msg;
	PeekMessage(&Msg, NULL, 0, 0, PM_NOREMOVE);
 
 
	while(Msg.message != WM_QUIT)
	{
			ReceptionMsg = PeekMessage(&Msg, NULL, 0, 0, PM_REMOVE);
			if(ReceptionMsg)
			{
				TranslateMessage(&Msg);
				DispatchMessage(&Msg);
			}
 
			else
			{
					// Mise à jour des vars de temps
					MajHorloge(flag_H);
 
					// Rendu
					Render();
			}
	}
 
	return 1;
 
}

Merci pour vos remarques et commentaires.
Sinon, si d'autres ont les mêmes écarts de performances entre les samples du SDK et leur applis, qu'ils n'hésitent pas à poster un message pour me le faire savoir.

A+

[Laurent Gomila]

Mon p'tit diagnostic :

Le framerate anormalement bas que tu as vient du fait que tu recrées entièrement ton objet LPD3DXFONT à chaque appel à DrawText. Crée le une fois lors de l'init et fais juste pD3DXFont->DrawText(...) dans ta fonction. Avec ton code j'avais 40 FPS, après correction j'avais 300.

Après ça tout est normal, si tu veux du 2000 FPS plutôt que du 300 il faut baisser la résolution, c'est juste une histoire de fillrate.

[Hidekii]

Arfffff !!
Je suis une patate !
Mais merci beaucoup !!
J'aurais jamais cru que c'était si con...

Qu'est ce que tu entends par fillrate ?
=> Taille et dim des backsbuffers ?

Merci bcp en tout cas !!!



PS : j'ai des framerate prodigieux maintenant
Je savais que $$crosoft ne faisait rien de magique dans son framework

[Laurent Gomila]

Le fillrate c'est le taux de remplissage de pixels (théorique) de ta carte. Tu peux donc avoir une grosse approximation du framerate theorique que tu devrais avoir en affichant un quad texturé sur tout l'ecran, par exemple (en enlevant le clear, lui il est fait de maniere optimisée ça fausse les calculs).

Exemple : si ta carte fait du 300 MTexels / sec, ça fait du 380 FPS en 1024x768. A prendre avec des énormes pincettes évidemment.

[delire8]

Salut !

Pour vous rassurer, j'ai exactement le meme probleme... mais paradoxalement, croyez moi si vous voulez, plus mon jeu avance.... plus mes FPS augmentent

Au début, scéne vide, optimisations basiques (pas l'erreur du D3DXFONT), j'avais 60fps (?!). La, dans les menus (pas entierements optimisés en plus, bah oui les menus ca nuit pas au gameplay ), j'ai 257fps et en plein jeu, au pire j'en ai 90 (non limités). Bien sur, depuis le début, il y a eu d'enormes optimisations, mais bon j'ai du débloquer une espece de limitation de fps ou accroitre la priorité de mon processus.