Textures procédurales temps réel

**idmapria** · 13/03/2012, 07h03

Bien donc comme le titre l'indique je cherche à générer en temps réel une texture pixel par pixel avec des algos maison en pur calcul CPU.

A la sortie de mon algo j'ai donc rempli un tableau d'unsigned long et je veux le copier dans une texture 32bit

J'ai essayé les techniques de débutant LockRect() et LoadSurfaceFromMemory() et j'ai une consommation processeur anormalement élevée alors que pourtant ma texture est toute petite

De deux choses l'une, soit je sais pas me servir correctement de ces fonctions, soit elles sont pas propre et donc il faut que j'utilise autre chose à la place...

Voilà mon code

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
//-----------------------------------------------------------------------------
// tripotage de source sample microzoft pour afficher une bête image 2d dans directx
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#include <Windows.h>
#include <mmsystem.h>
#include <d3dx9.h>
#pragma warning( disable : 4996 ) // disable deprecated warning 
#include <strsafe.h>
#pragma warning( default : 4996 )
 
//-----------------------------------------------------------------------------
// Global variables
//-----------------------------------------------------------------------------
 
const int texW = 512, texH = 512;
 
LPDIRECT3D9             g_pD3D = NULL; // Used to create the D3DDevice
LPDIRECT3DDEVICE9       g_pd3dDevice = NULL; // Our rendering device
LPDIRECT3DVERTEXBUFFER9 g_pVB = NULL; // Buffer to hold vertices
LPDIRECT3DTEXTURE9      g_pTexture = NULL; // Our texture
LPDIRECT3DTEXTURE9      g_pTextureOffA= NULL; // Our doublebuffer textures
LPDIRECT3DTEXTURE9      g_pTextureOffB= NULL;
LPDIRECT3DTEXTURE9		g_pTextureOff= NULL; // reference to the off texture
bool swap = false;
 
D3DLOCKED_RECT rect = {NULL,NULL}; // the lockrect
 
unsigned long int pixTable[texW*texH]; // the pixel table
 
int scrollX = 0;
 
RECT myrec = {0,0,texW,texH};
 
//IDirect3DSurface9 srf = NULL;
IDirect3DSurface9 *psrf = 0;
 
 
 
// vert structure
struct CUSTOMVERTEX
{
    D3DXVECTOR3 position; // The position
    D3DCOLOR color;    // The color
    FLOAT tu, tv;   // The texture coordinates
};
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE|D3DFVF_TEX1)
 
//-----------------------------------------------------------------------------
// Name: InitD3D()
// Desc: Initializes Direct3D
//-----------------------------------------------------------------------------
HRESULT InitD3D( HWND hWnd )
{
    // Create the D3D object.
    if( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
        return E_FAIL;
 
    // Set up the structure used to create the D3DDevice. Since we are now
    // using more complex geometry, we will create a device with a zbuffer.
    D3DPRESENT_PARAMETERS d3dpp;
    ZeroMemory( &d3dpp, sizeof( d3dpp ) );
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
	d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
 
    // Create the D3DDevice
    if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                                      D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                      &d3dpp, &g_pd3dDevice ) ) )
    {
        return E_FAIL;
    }
 
    // Turn off D3D lighting
    g_pd3dDevice->SetRenderState( D3DRS_LIGHTING, FALSE );
 
    return S_OK;
}
 
 
 
 
//-----------------------------------------------------------------------------
// Name: InitGeometry()
// Desc: Create the Textures and vertex buffers
//-----------------------------------------------------------------------------
HRESULT InitGeometry()
{
	// create ze textures
 
	if( FAILED( D3DXCreateTexture(g_pd3dDevice,texW,texH,0,D3DUSAGE_DYNAMIC,D3DFMT_X8R8G8B8,D3DPOOL_DEFAULT,&g_pTexture) ) )
    {
		MessageBox( NULL, L"Echec texture creation", L"Textures.exe", MB_OK );
        return E_FAIL;
    }
	if( FAILED( D3DXCreateTexture(g_pd3dDevice,texW,texH,0,D3DUSAGE_DYNAMIC,D3DFMT_X8R8G8B8,D3DPOOL_SYSTEMMEM,&g_pTextureOffA) ) )
    {
		MessageBox( NULL, L"Echec texture creation", L"Textures.exe", MB_OK );
        return E_FAIL;
    }
	if( FAILED( D3DXCreateTexture(g_pd3dDevice,texW,texH,0,D3DUSAGE_DYNAMIC,D3DFMT_X8R8G8B8,D3DPOOL_SYSTEMMEM,&g_pTextureOffB) ) )
    {
		MessageBox( NULL, L"Echec texture creation", L"Textures.exe", MB_OK );
        return E_FAIL;
    }
 
    // Create the vertex buffer.
    if( FAILED( g_pd3dDevice->CreateVertexBuffer( 4 * sizeof( CUSTOMVERTEX ),
                                                  0, D3DFVF_CUSTOMVERTEX,
                                                  D3DPOOL_DEFAULT, &g_pVB, NULL ) ) )
    {
        return E_FAIL;
    }
 
    // replit le vertex buffer avec mon rectangle. coordonnées pour trianglestrip: 0,2,1 - 2,3,1 - ...
 
    CUSTOMVERTEX* pVertices;
    if( FAILED( g_pVB->Lock( 0, 0, ( void** )&pVertices, 0 ) ) )
        return E_FAIL;
 
    pVertices[0].position = D3DXVECTOR3( -1.0f , -1.0f , 0.0f );
	pVertices[0].color = 0xffffffff;
    pVertices[0].tu = 0.0f;
    pVertices[0].tv = 1.0f;
 
    pVertices[2].position = D3DXVECTOR3(  1.0f , -1.0f , 0.0f );
	pVertices[2].color = 0xffffffff;
    pVertices[2].tu = 1.0f;
	pVertices[2].tv = 1.0f;
 
	pVertices[3].position = D3DXVECTOR3(  1.0f ,  1.0f , 0.0f );
	pVertices[3].color = 0xffffffff;
    pVertices[3].tu = 1.0f;
    pVertices[3].tv = 0.0f;
 
	pVertices[1].position = D3DXVECTOR3( -1.0f ,  1.0f , 0.0f );
	pVertices[1].color = 0xffffffff;
    pVertices[1].tu = 0.0f;
    pVertices[1].tv = 0.0f;
 
    g_pVB->Unlock();
 
    return S_OK;
}
 
 
 
 
//-----------------------------------------------------------------------------
// Name: Cleanup()
// Desc: Releases all previously initialized objects
//-----------------------------------------------------------------------------
VOID Cleanup()
{
    if( g_pTexture != NULL )
        g_pTexture->Release();
 
    if( g_pVB != NULL )
        g_pVB->Release();
 
    if( g_pd3dDevice != NULL )
        g_pd3dDevice->Release();
 
    if( g_pD3D != NULL )
        g_pD3D->Release();
}
 
 
 
// Define a function that matches the prototype of LPD3DXFILL3D
VOID WINAPI ColorFill (D3DXVECTOR4* pOut, const D3DXVECTOR2* pTexCoord, 
const D3DXVECTOR2* pTexelSize, LPVOID pData)
{
    *pOut = D3DXVECTOR4(pTexCoord->x, 0.0f, pTexCoord->y, 0.0f);
}
 
 
//-----------------------------------------------------------------------------
// Name: Render()
// Desc: Draws the scene
//-----------------------------------------------------------------------------
VOID Render()
{
    // Clear the backbuffer and the zbuffer
    g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                         D3DCOLOR_XRGB( 0, 0, 255 ), 1.0f, 0 );
 
    // Begin the scene
    if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
    {
		// call game routine here
 
		scrollX+=2;
 
		int i,j;
		for ( j = 0 ; j < texH ; j++ ) {
			for ( i = 0 ; i < texW ; i++ ) {				
 
				pixTable[ i + ( j << 9 ) ] = ((i+scrollX)&255)|((j&255)<<8);
 
			}
		}
 
		// update one texture
 
		swap = !swap;
		if ( swap ) g_pTextureOff = g_pTextureOffA; else  g_pTextureOff = g_pTextureOffB;
 
		// essai avec lockrect
 
		//g_pTextureOff->LockRect( 0, &rect, NULL, NULL );
		//memcpy( rect.pBits , &pixTable , rect.Pitch * texH );
		//g_pTextureOff->UnlockRect( 0 );
 
		// ==> CONSO CPU TROP ELEVEE
 
		// essai avec loadsurfacefrommemory
 
		g_pTextureOff->GetSurfaceLevel( 0, &psrf );
		D3DXLoadSurfaceFromMemory( psrf, NULL, &myrec, &pixTable, D3DFMT_X8R8G8B8, texW<<2, NULL , &myrec , D3DX_DEFAULT , 0x00000000 );
 
		// ==> CONSO CPU TROP ELEVEE AUSSI
 
 
 
		// display the other texture
 
		if ( swap ) g_pTextureOff = g_pTextureOffB; else  g_pTextureOff = g_pTextureOffA;
		g_pd3dDevice->UpdateTexture(g_pTextureOff, g_pTexture);
 
 
        // Setup the world
        g_pd3dDevice->SetTexture( 0, g_pTexture );
 
        // Render the vertex buffer contents
        g_pd3dDevice->SetStreamSource( 0, g_pVB, 0, sizeof( CUSTOMVERTEX ) );
        g_pd3dDevice->SetFVF( D3DFVF_CUSTOMVERTEX );
        g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 2 );
 
        // End the scene
        g_pd3dDevice->EndScene();
    }
 
    // Present the backbuffer contents to the display
    g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}
 
 
 
 
//-----------------------------------------------------------------------------
// Name: MsgProc()
// Desc: The window's message handler
//-----------------------------------------------------------------------------
LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
    switch( msg )
    {
        case WM_DESTROY:
            Cleanup();
            PostQuitMessage( 0 );
            return 0;
    }
 
    return DefWindowProc( hWnd, msg, wParam, lParam );
}
 
 
 
 
//-----------------------------------------------------------------------------
// Win32 Entry
//-----------------------------------------------------------------------------
 
INT WINAPI wWinMain( HINSTANCE hInst, HINSTANCE, LPWSTR, INT )
{
    // Register the window class
    WNDCLASSEX wc =
    {
        sizeof( WNDCLASSEX ), CS_CLASSDC, MsgProc, 0L, 0L,
        GetModuleHandle( NULL ), NULL, NULL, NULL, NULL,
        L"D3D Tutorial", NULL
    };
    RegisterClassEx( &wc );
 
    // Create the application's window
    HWND hWnd = CreateWindow( L"D3D Tutorial", L"D3D Tutorial 05: Textures",
                              WS_OVERLAPPEDWINDOW, 100, 100, 300, 300,
                              NULL, NULL, wc.hInstance, NULL );
 
    // Initialize Direct3D
    if( SUCCEEDED( InitD3D( hWnd ) ) )
    {
        // Create the scene geometry
        if( SUCCEEDED( InitGeometry() ) )
        {
            // Show the window
            ShowWindow( hWnd, SW_SHOWDEFAULT );
            UpdateWindow( hWnd );
 
            // Enter the message loop
            MSG msg;
            ZeroMemory( &msg, sizeof( msg ) );
            while( msg.message != WM_QUIT )
            {
                if( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )
                {
                    TranslateMessage( &msg );
                    DispatchMessage( &msg );
                }
                else
                    Render();
            }
        }
    }
 
    UnregisterClass( L"D3D Tutorial", wc.hInstance );
    return 0;
}

Bon, donc si j'ai bien compris, la problématique de base c'est qu'on fait des copies mémoire CPU->GPU ce qui est pas une opération évidente, parait que ça casse la synchro cpu/gpu donc ça doit pas plaire à la machine (peut-être bien que c'est à cause de ça que j'ai du cpu qui tourne pour rien ?)

C'est un procédé pas si simple que ça et ça m'étonnerait que ça se règle en une ligne de code

Peut-être déjà que j'appelle pas les fonctions au bon endroit... à savoir dans la routine normalement prévue au rendu de la scène, qui sollicite déjà le gpu

comme vous pouvez le voir je débute complet en directx donc jsuis un peu largué... y'a pas un deuxième event qui est appelé genre sur le laps de temps où cpu et gpu sont libres et qu'on peut faire des copies mémoire entre les 2 sans gâcher de ressource ?

j'ai essayé un genre de double buffering avec updatetexture mais ça change rien...

**idmapria** · 13/03/2012, 10h11

j'ai simplifié le code à l'extrême pour faire plus simple... j'ai viré la texture maintenant y'a juste la surface 2d du backbuffer

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
//-----------------------------------------------------------------------------
// tripotage de source sample microzoft pour afficher une bête image 2d dans directx
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#include <Windows.h>
#include <mmsystem.h>
#include <d3dx9.h>
#pragma warning( disable : 4996 ) // disable deprecated warning 
#include <strsafe.h>
#pragma warning( default : 4996 )
 
#include "game.h"
 
//-----------------------------------------------------------------------------
// Global variables
//-----------------------------------------------------------------------------
 
LPDIRECT3D9             g_pD3D = NULL; // Used to create the D3DDevice
LPDIRECT3DDEVICE9       g_pd3dDevice = NULL; // Our rendering device
 
// mes trucs pour les calculs copie ram->vram
 
const int scW = 512, scH = 512;
D3DLOCKED_RECT rect = {NULL,NULL}; // the lockrect
RECT myrec = {0,0,scW,scH};
IDirect3DSurface9 *psrf = 0;
 
 
//-----------------------------------------------------------------------------
// Name: InitD3D()
// Desc: Initializes Direct3D
//-----------------------------------------------------------------------------
HRESULT InitD3D( HWND hWnd )
{
    // Create the D3D object.
    if( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
        return E_FAIL;
 
    // Set up the structure used to create the D3DDevice. Since we are now
    // using more complex geometry, we will create a device with a zbuffer.
    D3DPRESENT_PARAMETERS d3dpp;
    ZeroMemory( &d3dpp, sizeof( d3dpp ) );
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
	d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
	d3dpp.BackBufferWidth = scW;
	d3dpp.BackBufferHeight = scH;
 
    // Create the D3DDevice
    if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                                      D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                      &d3dpp, &g_pd3dDevice ) ) )
    {
        return E_FAIL;
    }
 
    return S_OK;
}
 
 
//-----------------------------------------------------------------------------
// crée le gamengine
//-----------------------------------------------------------------------------
HRESULT InitTheGame()
{
	// init da game
 
	initGame();
 
    return S_OK;
}
 
 
//-----------------------------------------------------------------------------
// Name: Cleanup()
// Desc: Releases all previously initialized objects
//-----------------------------------------------------------------------------
VOID Cleanup()
{
    if( g_pd3dDevice != NULL )
        g_pd3dDevice->Release();
 
    if( g_pD3D != NULL )
        g_pD3D->Release();
}
 
 
 
// Define a function that matches the prototype of LPD3DXFILL3D
VOID WINAPI ColorFill (D3DXVECTOR4* pOut, const D3DXVECTOR2* pTexCoord, 
const D3DXVECTOR2* pTexelSize, LPVOID pData)
{
    *pOut = D3DXVECTOR4(pTexCoord->x, 0.0f, pTexCoord->y, 0.0f);
}
 
 
//-----------------------------------------------------------------------------
// Name: Render()
// Desc: Draws the scene
//-----------------------------------------------------------------------------
VOID Render()
{
    // Clear the backbuffer and the zbuffer
    /*g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                         D3DCOLOR_XRGB( 0, 0, 255 ), 1.0f, 0 );*/
 
    // Begin the scene
    if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
    {
		// call game routine here
 
		routineGame( );
		unsigned long int * scrAddr = getScreenAdress();
 
		g_pd3dDevice->GetRenderTarget( 0, &psrf );
 
		// essai avec lockrect
 
		//g_pTexture->LockRect( 0, &rect, NULL, NULL );
		//memcpy( rect.pBits , scrAddr , rect.Pitch * texH );
		//g_pTexture->UnlockRect( 0 );
 
		// essai avec loadsurfacefrommemory
 
		D3DXLoadSurfaceFromMemory( psrf, NULL, &myrec, scrAddr, D3DFMT_X8R8G8B8, scW<<2, NULL , &myrec , D3DX_DEFAULT , 0x00000000 );
 
        // End the scene
        g_pd3dDevice->EndScene();
    }
 
    // Present the backbuffer contents to the display
    g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}
 
 
 
 
//-----------------------------------------------------------------------------
// Name: MsgProc()
// Desc: The window's message handler
//-----------------------------------------------------------------------------
LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
    switch( msg )
    {
        case WM_DESTROY:
            Cleanup();
            PostQuitMessage( 0 );
            return 0;
    }
 
    return DefWindowProc( hWnd, msg, wParam, lParam );
}
 
 
 
 
//-----------------------------------------------------------------------------
// Win32 Entry
//-----------------------------------------------------------------------------
 
INT WINAPI wWinMain( HINSTANCE hInst, HINSTANCE, LPWSTR, INT )
{
    // Register the window class
    WNDCLASSEX wc =
    {
        sizeof( WNDCLASSEX ), CS_CLASSDC, MsgProc, 0L, 0L,
        GetModuleHandle( NULL ), NULL, NULL, NULL, NULL,
        L"D3D Tutorial", NULL
    };
    RegisterClassEx( &wc );
 
    // Create the application's window
 
	RECT wr = {0, 0, scW, scH};    // set the size, but not the position
	AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);    // adjust the size
 
    HWND hWnd = CreateWindow( L"D3D Tutorial", L"truc de merde",
								WS_OVERLAPPEDWINDOW, 300, 300, wr.right-wr.left, wr.bottom-wr.top,
								NULL, NULL, wc.hInstance, NULL );
 
    // Initialize Direct3D
    if( SUCCEEDED( InitD3D( hWnd ) ) )
    {
        // Create the scene geometry
        if( SUCCEEDED( InitTheGame() ) )
        {
            // Show the window
            ShowWindow( hWnd, SW_SHOWDEFAULT );
            UpdateWindow( hWnd );
 
            // Enter the message loop
            MSG msg;
            ZeroMemory( &msg, sizeof( msg ) );
            while( msg.message != WM_QUIT )
            {
                if( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )
                {
                    TranslateMessage( &msg );
                    DispatchMessage( &msg );
                }
                else
                    Render();
            }
        }
    }
 
    UnregisterClass( L"D3D Tutorial", wc.hInstance );
    return 0;
}

mais niveau perfs ça ne change rien...

pour vous donner une idée des perf, pour une image de 512*512 j'ai une moyenne de 7% de mon 6ghz avec un worst case de 10% ... donc ça tiendrait pas la route sur un smartphone avec un process 500mhz... pour une résolution aussi pauvre c'est rageant

après peut-être que sur les smartphone ce genre d'opération est mieux gérés que sur windows... jsais aps

**Mat.M** · 13/03/2012, 10h50

Salut je ne comprends pas à quoi sert la Direct3dSurface
IDirect3DSurface9 *psrf = 0;

Sinon si tu cherches les performances il faut éviter les fonctions DX ( Direct X extensions) comme D3DXLoadSurfaceFromMemory

http://www.gamedev.net/topic/352178-...emory-is-slow/

**math_lab** · 13/03/2012, 10h54

Je conseillerais aussi de faire passer ça par des shaders. Soit tu crées ta texture a la volée pendant le shading de ton objet (donc sans passer par une image), soit tu crées ta texture en faisant un rendu off-screen utilisant aussi un shader. Ça évitera d'avoir a transférer des textures dans tous les sens (et 512*512, c'est gros, surtout s'il faut calculer les mipmaps a chaque fois).

**idmapria** · 13/03/2012, 12h34

Envoyé par Mat.M

Salut je ne comprends pas à quoi sert la Direct3dSurface
IDirect3DSurface9 *psrf = 0;

Ben c'est bêtement le pointeur vers l'adresse mémoire vidéo où j'écris. La surface peut être directement l'offscreen buffer ou alors un niveau d'une texture.

Envoyé par Mat.M

Sinon si tu cherches les performances il faut éviter les fonctions DX ( Direct X extensions) comme D3DXLoadSurfaceFromMemory

http://www.gamedev.net/topic/352178-...emory-is-slow/

dans ce topic je lis des trucs sur lockrect() mais j'ai testé ça bouffe autant de cpu que loadsurfacefrommemory...

Je conseillerais aussi de faire passer ça par des shaders. Soit tu crées ta texture a la volée pendant le shading de ton objet (donc sans passer par une image), soit tu crées ta texture en faisant un rendu off-screen utilisant aussi un shader. Ça évitera d'avoir a transférer des textures dans tous les sens (et 512*512, c'est gros, surtout s'il faut calculer les mipmaps a chaque fois).

ouai j'ai lu ça aussi... j'ai pas regardé de trop près encore, je sais pas trop si un shader qui lit dans la ram et écrit dans le gpu ça serait bien compatible partout... mais je vais mater

**wax78** · 13/03/2012, 14h24

Envoyé par idmapria

je sais pas trop si un shader qui lit dans la ram et écrit dans le gpu ça serait bien compatible partout... mais je vais mater

A moins que j'ai mal compris cette phrase, un shader na va pas lire dans la Ram (dans la vram par l'intermediaire d'une texture ou autre certes) mais dans la ram non ^^

**math_lab** · 13/03/2012, 15h01

Envoyé par wax78

A moins que j'ai mal compris cette phrase, un shader na va pas lire dans la Ram (dans la vram par l'intermediaire d'une texture ou autre certes) mais dans la ram non ^^

Oui, le principe c'est d'envoyer la texture vide dans le gpu une fois au début du programme et ensuite de faire tout ton bazar exclusivement sur gpu pour éviter de déplacer l'image entre le coté CPU et le coté GPU.

**idmapria** · 13/03/2012, 19h59

ahaha... ouais je me disais aussi...

Bon donc... je reprends... à titre de référence je viens de tester un petit truc en pur rendu cpu qui s'affiche en directx et donc qui refresh une surface ou texture vram à chaque frame, hé ben la consommation cpu est quasi nulle

Donc c'est bien qu'elle existe la méthode optimisée pour màj une surface. le truc c'est que j'ai passé des plombes à chercher avec google et cette technique pourtant super basique a l'air d'être une grande inconnue sur les forums directx.

sur le forum de mat.m je lis qu'il y'a une histoire de régler le problème de synchro cpu/gpu lié à la méthode RectLock() mais leurs explications restent très théoriques et allusives

**idmapria** · 13/03/2012, 20h24

J'ai une autre piste là.

je sais pas si je cherche dans la bonne direction: http://msdn.microsoft.com/en-us/libr...=vs.85%29.aspx

**LeGreg** · 13/03/2012, 20h31

Tu ne passes aucun flag à LockRect.

Tu pourrais au moins lui passer un flag discard pour lui signifier qu'il n'a pas besoin d'attendre la fin du rendu précédent pour commencer la copie. Et t'assurer que ta texture a été créée avec les bons flags (default dynamic texture et non pas managed texture).
http://msdn.microsoft.com/en-us/libr...=vs.85%29.aspx

Ensuite, tout dépend de ce que tu veux faire mais :
1- si ta texture procédurale n'est pas trop compliquée ça peut-être plus simple et rapide à générer avec des shaders. (et si c'est compliqué.. et bien ça a encore plus de raisons d'être généré sur un processeur parallèle rapide comme le GPU)
2- rien ne t'empêche de générer ta texture directement dans le buffer qui t'es retourné par le lockrect, ce qui t'économiseras une copie. Ceci dit, attention à ne pas faire de read/modify/write (écrire des mots de 32 bits alignés uniquement).
3- memcpy( rect.pBits , scrAddr , rect.Pitch * texH ); <- ça va casser parce que ça ne prend pas en compte le pitch différent de ta source et de ta destination.
4- ça peut être intéressant d'aligner les adresses de démarrage de ta source et de ta destination (sur 16 octets ?).
4- Comment tu évalues que le coût CPU est trop élevé ? Tu comptes le nombre de cycles requis pour updater ta texture ? tu compares juste le framerate avant et après ?

**LeGreg** · 13/03/2012, 20h35

Envoyé par idmapria

J'ai une autre piste là.

je sais pas si je cherche dans la bonne direction: http://msdn.microsoft.com/en-us/libr...=vs.85%29.aspx

Non mauvaise direction !

Envoyé par idmapria

le truc c'est que j'ai passé des plombes à chercher avec google et cette technique pourtant super basique a l'air d'être une grande inconnue sur les forums directx.

Déjà essaie de lire et comprendre la documentation DirectX de base.

**idmapria** · 13/03/2012, 20h55

Envoyé par LeGreg

Tu ne passes aucun flag à LockRect.

Tu pourrais au moins lui passer un flag discard pour lui signifier qu'il n'a pas besoin d'attendre la fin du rendu précédent pour commencer la copie.

je vais tester ça

Envoyé par LeGreg

Et t'assurer que ta texture a été créée avec les bons flags (default dynamic texture et non pas managed texture).
[url]http://msdn.microsoft.com/en-us/library/windows/desktop/bb147263%28v=vs.85%29.aspx

il me semble que c'est les flags que j'avais mis

Ensuite, tout dépend de ce que tu veux faire mais :
1- si ta texture procédurale n'est pas trop compliquée ça peut-être plus simple et rapide à générer avec des shaders. (et si c'est compliqué.. et bien ça a encore plus de raisons d'être généré sur un processeur parallèle rapide comme le GPU)

Non justement, c'est pour afficher des demomake de rendu cpu... donc pas de rendu gpu.

2- rien ne t'empêche de générer ta texture directement dans le buffer qui t'es retourné par le lockrect, ce qui t'économiseras une copie. Ceci dit, attention à ne pas faire de read/modify/write (écrire des mots de 32 bits alignés uniquement).

J'ai essayé et ça ne change rien.

Ce n'est pas la copie qui consomme du cpu (copier 512*512*4 oct pour les cpu de maintenant ça ne consomme rien du tout)

Les 2 lignes de code qui me pètent le CPU c'est LockRect()/unlockRect() (ça bouffe autant de cpu que loadsurfacefrommemory). que je copie des pixels ou pas ne change rien, même à vide ça pompe le cpu

j'ai lu que c'est parce que lockrect casse la synchro cpu/gpu et donc que le process aime pas ça et qu'il se met à tourner pour rien afin de rattraper un truc désynchronisé, et donc que c'est pas ça qu'il faut utiliser

à vrai dire ça m'étonnerait beaucoup que la délicate opération d'un flux proprement synchro de copie ram->vram se règle bêtement en trois lignes de code en taillant à la hache comme un porc dans la vram avec un lockrect

écrire bêtement les pixels de la mémoire vidéo c'est ce qu'on faisait sur ms-dos à l'ére du rendu full-cpu, je suis convaincu qu'avec le rendu gpu c'est un tantinet plus compliqué, (non seulement parce qu'il faut synchro deux puces qui tournent en parallèle, mais aussi parce que d'un gpu à l'autre les pixels et les pitch vont pas forcément être formatés de la même manière)

je sais pas si je cherche dans la bonne direction: http://msdn.microsoft.com/en-us/libr...=vs.85%29.aspx
Non mauvaise direction !

ha ?? ça m'a pourtant l'air d'être la doc officielle de microsoft sur les surfaces procédurales...

bon je suis ptêt pas sur la bonne page. as-tu la bonne page ?

**LeGreg** · 13/03/2012, 21h22

Envoyé par idmapria

j'ai lu que c'est parce que lockrect casse la synchro cpu/gpu et donc que le process aime pas ça et qu'il se met à tourner pour rien afin de rattraper un truc désynchronisé, et donc que c'est pas ça qu'il faut utiliser

Mais comment tu sais que c'est du coût CPU et pas juste le CPU qui attends bêtement le GPU (cf flag discard) ? Et quels sont les chiffres qui te font dire que le coût est trop important ? Quel est le coût de ta frame sur le GPU ? Est-ce que tu fais un lockrect à chaque frame ou une frame sur trois ?

Pour le parallelisme il n'y a rien de magique : le GPU trace, le CPU fait des calculs, de temps à autre il y a besoin de faire une synchronisation. Si tu utilises les bons outils pas besoin de synchronization trop fréquente.

Ceci dit, la situation n'était pas parfaite sous Dx9 et il y a eu des améliorations sous Dx10/dx11 (staging buffers), mais pas sûr que ça soit un problème pour toi..

**idmapria** · 13/03/2012, 21h44

les vieilles versions de directx savaient déjà très bien le faire

c'est normal je cherche à faire un truc complètement basique que directx savait faire déjà à l'époque d'avant la 3d

sinon à propos de la-doc-de-base-pour-débutants de directx, ça m'explique comment faire des triangles et des matrices et puis y balancer une texture bêtement convertie depuis un bmp avec une fonction toute faite... j'ai joué avec pour voir mais bon ça m'intéresse pas, je cherche pas à faire de la 3d, je cherche à afficher proprement un tableau de pixels dans windows et rien d'autre

entre les techniques de porc qui bâclent ça n'importe comment en 3 lignes avec des méthodes de bourrin, et les code exemples interminables de microsoft qui font des centaines de lignes, je suis sûr qu'il y'a un juste milieu...

**LeGreg** · 13/03/2012, 21h50

tu ne réponds pas aux questions :
c'est quoi tes perfs? c'est quoi trop pour toi? tu as essayé de discard ? les surfaces ddraw dans Directx7 n'avaient pas de swizzling/tiling à l'époque et globalement un lock ou un blit dans ddraw c'est la même chose que ce que tu peux faire avec directx9 via lockrect, updatesurface, stretchrect (au niveau du driver ce sera le même chemin avec parfois des différences au niveau swizzling/tiling et le fait aussi que les applis ddraws ne peuvent pas accumuler aussi facilement autant de travail pour le GPU dans leur queue).

**LeGreg** · 13/03/2012, 22h02

Quant à D3DX ils ne font rien de spécial non plus, ce sont juste des helper fonctions qui en sous-main appellent les mêmes fonctions sur le device d3d.
Bien entendu chaque fonction d3dx a un certain usage derrière la tête donc ne sera pas forcément adaptée pour ton problème. Ce qui veut dire dans ton cas l'appel à D3DX n'apportera probablement rien.

**idmapria** · 13/03/2012, 22h02

ben j'ai regardé la "conso cpu" (enfin le cpu qui "attend"...) sur le process manager et c'est très nettement au dessus de ce que je peux observer sur des petits trucs de rendu cpu flouté par le hardware (genre émulateurs ou vieux jeux windows)

et puis j'ai fait des recherches sur des forums et y'a des mecs ils disent que c'est normal parce que LockRect() c'est un truc de gros porc

http://www.gamedev.net/topic/72059-i...ect-efficient/

just because you see one person who is a "guru" saying that using LockRect() is THE way to do 2d, does not mean its efficent. The facts are here, make up your own mind:

1. LockRect() stalls the pipeline if ANY previous calls would have used that surface, reducing parrallism with the cpu and card.

2. Reading from VRAM is slow, especially in the scenario or trying to do alpha blits or any compartive blits passed on destination. you should use the hardware for that.

3. LockRect() while not slow if used correctly, can like anything else when overused will slow yoru app down quite easily. just like improperly used vertex buffers. good uses include dynamic textures. (btw to update sprite frames you can just change the texture coordinates, but then the whole vertex buffer thing might become an issue)

4. the author of the book is merely calling himself a Zen Guru for marketing. i highly doubt he knows dx8 as well as you believe he does.

5. i can almost garuntee, that the actual frames drawn to the screen are done using textured quads. dx8 was not designed for directdraw style 2d.

6. LockRect() just like locking your frame buffer in dx7 is NOT the MOST effiecent way for drawing sprites. if you need alpha blend in directdraw you would use lock() but on local surfaces. in dx8, you let the video card handle unless you want the cpu to do all the work, thus mooting the point of using dx8 for 2d graphics.

bon pour aller à l'essentiel. ce que je veux faire est simple. afficher proprement dans windows un tableau de pixels "rendu cpu", comme le font les émulateurs ou les portages de vieux jeux ms dos sur windows.

je crois que je vais aller éventrer leurs sources pour trouver la solution

**LeGreg** · 13/03/2012, 22h17

Il parle d'alpha blending. Et il parle d'appel bloquant (sans le flag discard). SI (et seulement si) tu fais de l'alpha blending ou alpha testing ou une update partielle alors faire le compositing sur le CPU est totalement inefficient. Dans ce cas il vaut mieux passer par une texture intermédiaire et faire le compositing sur le GPU.

Bref pas le même problème que ton problème.

ben j'ai regardé la "conso cpu" (enfin le cpu qui "attend"...) sur le process manager

Et c'est quoi ton nombre d'images par secondes ?

La conso CPU dans le process manager n'est pas un bon indicateur dans ton cas. Le CPU pourrait être à 100% à rendre aussi vite qu'il le peut.

**idmapria** · 13/03/2012, 22h49

mon nombre d'images par seconde ben tu regardes sur mon code c'est l'event calé sur la vsync, donc 60hz comme les émulateurs

oui je sais que l'indicateur du process manager n'est aucunement significatif des calculs requis par le processeur, mais bon si ça m'indique que le cpu patine bah c'est qu'il y'a un problème (et un gâchis de ressource)

bon, peu importe,

ça répond pas à ma question, comment qu'on affiche proprement un tableau de pixels mis à jour temps réel sur windows avec floutage+vsync hardware et sans faire de gâchis de cpu qui tourne pour rien

bref la base quoi

**LeGreg** · 13/03/2012, 23h03

Ben tu n'as toujours pas utilisé le flag discard.

Parce que là c'est probablement 100% du CPU à attendre dans le lock que le vsync passe..

Certes le lock pourrait éventuellement utiliser moins de ressources CPU (similaire au Present), mais c'est un problème lié au driver. (et tu peux faire un lockrect do not wait pour éviter de surcharger le CPU si tu as encore des tâches CPU autres à effectuer avant la frame suivante).

Textures procédurales temps réel

DirectX

Discussions similaires

Partager

Partager