Aide pour mon application "tetris"

**paladice** · 19/03/2012, 00h16

Bonjour à tous

.

Tous d'abord, merci à vous de prendre le temps de lire mon message

.
Je suis étudiant en informatique, et pour m'exercer pour mon partiel j'essaie de créer un Tetris avec directx 11 (ou 10 mais ceci est justement le sujet d ema question ^^)
Pour l'instant ça se passe pas trop mal même si je n'avance pas du tout à la vitesse que je voudrais

.
Je ne vous demanderais pas de me donner un code source complet mais si vous pouviez m'aider à corriger le mien ça serait déjà fort sympathique =).
Voilà, j'ai deux petits problèmes en ce moment.
Le premier concerne la vitesse de mon application. J'ai commencé à coder en directx 11 mais apparemment si je code en directx 10 mon application seras plus rapide. Seulement, le problème est que j'utilise un vertex shader avec un buffer structuré et que cela n'est pas possible en directx 10 (d'après ce que j'ai compris). Donc, on m'a proposé d'utiliser un geometric shader. Cependant, j'ai beaucoup de mal à comprendre le concept. Donc une petite aide de votre part ne serait pas de refus.
Mon second problème vient de la rotation de mes objets. Pour l'instant je n'ai qu'un seul objet (qui représente une barre de 4 quads) et j'arrive à le faire translater mais les rotations s'effectue par rapport au centre de la fenêtre et pas par rapport à l'objet. Donc si vous aviez une idée aussi là-dessus ça serait sympa

.

Je précise que le tetris est en 2D.

Voilà mon code, parce que sans code ça serait difficile lol :

main.cpp :

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
#include <Windows.h>
#include "console.h"
#include <iostream>
#include <d3d11.h>
#include <d3dx11.h>
#include <DxErr.h>
#include <vector>
#include <DXUT.h>
#include "ConstantBuffer.h"
#include "Sprite.h"
#include "Structure.h"
#pragma comment(lib,"dxgi.lib")
#pragma comment(lib,"d3d11.lib")
#pragma comment(lib,"d3dx11.lib")
#pragma comment(lib,"DxErr.lib")
#pragma comment(lib,"dxguid.lib")
#pragma comment(lib,"dxut.lib")
#pragma comment(lib,"d3dx9.lib")
#pragma comment(lib,"comctl32.lib")
#pragma comment(linker, "/nodefaultlib:MSVCRT") 
using namespace std;
 
#define _V(x) { HRESULT h=x; if (FAILED(h)) { MessageBoxA(NULL, __FUNCTION__ ":" #x " failed.","Error",MB_OK); return h; } }
#define _Vc(x) { HRESULT h=x; if (FAILED(h)) { MessageBoxA(NULL,(LPCSTR)(pErrMsg->GetBufferPointer()),#x,MB_OK); return h; } }
inline UINT Mult16(UINT x) { if ((x & 0x0f) == 0) return x; else return ((x>>4) + 1)<<4; }
 
const int NB_ELTS = 5000;
const int width = 800;
const int height = 600;
const int nbSpriteDansImgEnLargeur = 8;
const int nbSpriteDansImgEnHauteur = 1;
const float ratio = width/height;
const float scale = 1;
 
Sprite						*spritesBackground = new Sprite(1); //image CPU des sprites
Sprite						*spritesCarres = new Sprite(NB_ELTS); //image CPU des sprites
ConstantBuffer				constBuf;
 
ID3D11Texture2D				*pBackground;
ID3D11Texture2D				*pCarres;
ID3D11ShaderResourceView	*pSrvBackground;
ID3D11ShaderResourceView	*pSrvCarres;
ID3D11SamplerState			*pSampler;
 
HRESULT WINAPI OnCreateDevice(ID3D11Device *device, CONST DXGI_SURFACE_DESC * pBackBufferSurfaceDesc, void* pUserContext) {
	Scene &s = *static_cast<Scene*>(pUserContext);
	UINT stride=sizeof(Sprite_struct); //taille de la structure sprite_struct
	ID3D11DeviceContext *immediate = DXUTGetD3D11DeviceContext();
 
	// -----------------------------VERTEX BUFFER--------------------------------------------------------------------//
	D3DXVECTOR2 caraObjet[4] = {D3DXVECTOR2(-1.0f,1.0f), D3DXVECTOR2(1.0f,1.0f), D3DXVECTOR2(-1.0f,-1.0f), D3DXVECTOR2(1.0f,-1.0f)};
	D3D11_BUFFER_DESC VertexBufDesc = { 4*sizeof(D3DXVECTOR2), D3D11_USAGE_IMMUTABLE, D3D11_BIND_VERTEX_BUFFER, 0,0,0 };
	D3D11_SUBRESOURCE_DATA BufData = {caraObjet, 0, 0 };
	device->CreateBuffer(&VertexBufDesc, &BufData, &s.pVertexBuffer);
 
	// ----------------------------------------------------------SPRITE BUFFER ET VIEW-----------------------------------------//
	// Creation du buffer sprite
	D3D11_BUFFER_DESC BufDescBackground = CD3D11_BUFFER_DESC(	1*stride, 
													D3D11_BIND_SHADER_RESOURCE, 
													D3D11_USAGE_DYNAMIC, 
													D3D11_CPU_ACCESS_WRITE, 
													D3D11_RESOURCE_MISC_BUFFER_STRUCTURED, 
													stride);
	device->CreateBuffer(&BufDescBackground, NULL, &s.pSpriteBufferBackground);
 
	D3D11_BUFFER_DESC BufDescCarres = CD3D11_BUFFER_DESC(	NB_ELTS*stride, 
													D3D11_BIND_SHADER_RESOURCE, 
													D3D11_USAGE_DYNAMIC, 
													D3D11_CPU_ACCESS_WRITE, 
													D3D11_RESOURCE_MISC_BUFFER_STRUCTURED, 
													stride);
	device->CreateBuffer(&BufDescCarres, NULL, &s.pSpriteBufferCarres);
 
	// Creation du shader sprite
	D3D11_SHADER_RESOURCE_VIEW_DESC srvd;
	srvd.Format = DXGI_FORMAT_UNKNOWN; // format précisé dans le shader
	srvd.ViewDimension = D3D11_SRV_DIMENSION_BUFFEREX;
	srvd.Buffer.ElementOffset = 0;
	srvd.Buffer.ElementWidth = 1;
	device->CreateShaderResourceView(s.pSpriteBufferBackground, &srvd, &s.pSpriteBufferSRVBackground );
 
	srvd.Format = DXGI_FORMAT_UNKNOWN; // format précisé dans le shader
	srvd.ViewDimension = D3D11_SRV_DIMENSION_BUFFEREX;
	srvd.Buffer.ElementOffset = 0;
	srvd.Buffer.ElementWidth = NB_ELTS;
	device->CreateShaderResourceView(s.pSpriteBufferCarres, &srvd, &s.pSpriteBufferSRVCarres);
 
	//------------------------------- CONSTANT BUFFER---------------------//
 
	D3DXMATRIX MWorld = D3DXMATRIX(1,0,0,0,
									0,1,0,0,
									0,0,1,0,
									0,0,0,1);
	constBuf = MWorld;
 
	D3D11_BUFFER_DESC cBufDesc;
	ZeroMemory(&cBufDesc,sizeof(cBufDesc));
	cBufDesc.ByteWidth = Mult16(sizeof( ConstantBuffer ) );
	cBufDesc.Usage = D3D11_USAGE_DYNAMIC;
	cBufDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
	cBufDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
	device->CreateBuffer( &cBufDesc, NULL, &s.pConstantBuffer);
 
	// ------------------------------------------------------------TEXTURE VIEW---------------------------------//
 
	ID3D11Resource *pRes = NULL;
 
	//chargement du tileset
 
	D3DX11CreateTextureFromFileA(device, "backGround.png", NULL, NULL, &pRes, NULL);
	pRes->QueryInterface(__uuidof(ID3D11Texture2D),(void**)&pBackground );
	SAFE_RELEASE(pRes);
	device->CreateShaderResourceView(pBackground, NULL, &pSrvBackground);
 
	//chargement du tileset
 
	D3DX11CreateTextureFromFileA(device, "carresB.png", NULL, NULL, &pRes, NULL);
	pRes->QueryInterface(__uuidof(ID3D11Texture2D),(void**)&pCarres );
	SAFE_RELEASE(pRes);
	device->CreateShaderResourceView(pCarres, NULL, &pSrvCarres);
 
	//**********************************
	//* Echantillonneur
	//**********************************
 
	//chargement de la configuration par défaut
	CD3D11_DEFAULT default;
	CD3D11_SAMPLER_DESC sd(default);
 
	//configuration de l'échantillonneur
	sd.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
	sd.AddressU = sd.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
 
	//création et attachement au Pixel Shader
	device->CreateSamplerState(&sd,&pSampler);
	immediate->VSSetSamplers(0,1,&pSampler);
	immediate->VSSetSamplers(0,1,&pSampler);
 
 
	// -----------------------------COMPILATION VERTEX/PIXEL SHADERS ET CREATION INPUT LAYOUT---------------------------------//
	ID3D10Blob 			*pCode = NULL, *pErrMsg = NULL;
	_Vc( D3DX11CompileFromFileA("Shader.fx", NULL, NULL, "VSmain", "vs_4_0", 0, 0, NULL, &pCode, &pErrMsg, NULL) );
	_V( device->CreateVertexShader( pCode->GetBufferPointer(), pCode->GetBufferSize(), NULL, &s.pVertexShader) );
	D3D11_INPUT_ELEMENT_DESC layout={ "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 };
	_V( device->CreateInputLayout( &layout, 1, pCode->GetBufferPointer(), pCode->GetBufferSize(), &s.pInputLayout) );
	SAFE_RELEASE(pCode); 
	SAFE_RELEASE(pErrMsg);
	_Vc( D3DX11CompileFromFileA("Shader.fx", NULL, NULL, "PSmain", "ps_4_0", 0, 0, NULL, &pCode, &pErrMsg, NULL) );
	_V( device->CreatePixelShader( pCode->GetBufferPointer(), pCode->GetBufferSize(), NULL, &s.pPixelShader) );
	SAFE_RELEASE(pCode); 
	SAFE_RELEASE(pErrMsg);
 
	//**********************************
	//* Initialisation
	//**********************************
 
	D3DXMATRIX matriceInit = D3DXMATRIX(1,	0,	0,	0,
										0,	1,	0,	0,
										0,	0,	1,	0,
										0,	0,	0,	1);
 
	D3DXVECTOR2 uv = D3DXVECTOR2(0.0f, 0.0f);
 
	spritesBackground->add(D3DXVECTOR3(0.f,0.f,0.9f),1,uv,D3DXVECTOR2(1.f,1.f), D3DXVECTOR2(1.f,1.f), matriceInit);
 
	//D3DXVECTOR2 uvCarreUn = D3DXVECTOR2(0.0f, 0.0f);
	//D3DXVECTOR2 uvCarreDeux = D3DXVECTOR2(1.0f/8.0f, 0.0f);
	//D3DXVECTOR2 uvCarreTrois = D3DXVECTOR2(2.0f/8.0f, 0.0f);
	D3DXVECTOR2 uvCarre = D3DXVECTOR2(0.0f, 0.0f);
 
	spritesCarres->add(D3DXVECTOR3(-24.f,20.f,0.1f),1,uvCarre,D3DXVECTOR2(1.f/8.f,1.f/6.f), D3DXVECTOR2(0.025f,0.03125f), matriceInit);
	spritesCarres->add(D3DXVECTOR3(-24.f,18.f,0.1f),1,uvCarre,D3DXVECTOR2(1.f/8.f,1.f/6.f), D3DXVECTOR2(0.025f,0.03125f), matriceInit);
	spritesCarres->add(D3DXVECTOR3(-24.f,16.f,0.1f),1,uvCarre,D3DXVECTOR2(1.f/8.f,1.f/6.f), D3DXVECTOR2(0.025f,0.03125f), matriceInit);
	spritesCarres->add(D3DXVECTOR3(-24.f,14.f,0.1f),1,uvCarre,D3DXVECTOR2(1.f/8.f,1.f/6.f), D3DXVECTOR2(0.025f,0.03125f), matriceInit);
	// plus z est elevé, plus le sprite est eloigné
 
	return S_OK;
};
 
void WINAPI OnFrameMove( double fTime, float fElapsedTime, void* pUserContext ) {
 
};
 
void WINAPI OnFrameRender(ID3D11Device *device, ID3D11DeviceContext *context, DOUBLE fTime, FLOAT fElapsedTime, void* pUserContext) {
	Scene &s = *static_cast<Scene*>(pUserContext);	
	ID3D11Buffer *pCBnull = NULL;
	HRESULT h;
 
	float ClearColor[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; //red,green,blue,alpha
	context->ClearRenderTargetView( DXUTGetD3D11RenderTargetView(), ClearColor );
	context->ClearDepthStencilView( DXUTGetD3D11DepthStencilView(), D3D10_CLEAR_DEPTH, 1.f, 0);	
	UINT	stride=sizeof(D3DXVECTOR2), offset=0;
 
	// -------------------- PREMIERE ETAPE - AFFICHER LE BACKGROUND ------------------------------//
 
	// mise à jour du buffer structuré de la texture
	D3D11_MAPPED_SUBRESOURCE Mapped2;
	ID3D11ShaderResourceView *NoRes=NULL;
	context->VSSetShaderResources(0,1,&NoRes);
	h=context->Map(s.pSpriteBufferBackground, 0, D3D11_MAP_WRITE_DISCARD, 0, &Mapped2);
 
	CopyMemory(Mapped2.pData,spritesBackground->getData(),Mult16(spritesBackground->getDataSize())); //spritesCPU->getData()
 
	context->Unmap(s.pSpriteBufferBackground, 0);
 
	// CBUFFER //
	// détache le buffer de constante du pipeline
	pCBnull = NULL;
	context->VSSetConstantBuffers(0, 1, &pCBnull);
	context->PSSetConstantBuffers(0, 1, &pCBnull);
	// mise à jour du buffer de constantes
	D3D11_MAPPED_SUBRESOURCE Mapped;
	context->Map(s.pConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &Mapped);
	CopyMemory(Mapped.pData, &constBuf, sizeof(ConstantBuffer) );
	context->Unmap(s.pConstantBuffer, 0);
	// réattache le buffer de constante du pipeline
	context->VSSetConstantBuffers(0, 1, &s.pConstantBuffer);
	context->PSSetConstantBuffers(0, 1, &s.pConstantBuffer);
 
	// configuration du pipeline
	UINT Stride=sizeof(D3DXVECTOR2), Zero=0;
	context->IASetVertexBuffers(0,1,&s.pVertexBuffer,&Stride,&Zero);
	context->IASetInputLayout(s.pInputLayout);
	context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
 
	context->VSSetConstantBuffers(0,1,&s.pConstantBuffer);
	context->VSSetShaderResources(0,1,&s.pSpriteBufferSRVBackground);
	context->VSSetShader(s.pVertexShader,NULL,0);
 
	context->PSSetConstantBuffers(0,1,&s.pConstantBuffer);
	context->PSSetShader(s.pPixelShader,NULL,0);
 
	//ID3D11ShaderResourceView *pSRVarray[3] = { pSrv1, pSrv2, pSrv3 };
	ID3D11ShaderResourceView *pSRVarray[1] = { pSrvBackground};
	context->PSSetShaderResources(0,1,pSRVarray);
 
	// draw multi-instance
	//if (spritesCPU->getN() > 0) context->DrawInstanced(4,spritesCPU->getN(),0,0);
	context->DrawInstanced(4,spritesBackground->getN(),0,0);
 
 
 
 
	//----------------------DEUXIEME ETAPE, AFFICHER LES CARRES -------------------------//
 
	// mise à jour du buffer structuré
	NoRes=NULL;
	context->VSSetShaderResources(0,1,&NoRes);
	h=context->Map(s.pSpriteBufferCarres, 0, D3D11_MAP_WRITE_DISCARD, 0, &Mapped2);
	CopyMemory(Mapped2.pData,spritesCarres->getData(),Mult16(spritesCarres->getDataSize())); //spritesCPU->getData()
	context->Unmap(s.pSpriteBufferCarres, 0);
	context->VSSetShaderResources(0,1,&s.pSpriteBufferSRVCarres);
 
	ID3D11ShaderResourceView *pSRVarrayCarre[1] = {pSrvCarres};
	context->PSSetShaderResources(0,1,pSRVarrayCarre);
	context->DrawInstanced(4,spritesCarres->getN(),0,0);
 
}
 
 
void WINAPI OnDestroyDevice(void* pUserContext) {
	Scene *s = static_cast<Scene*>(pUserContext);
 
	SAFE_RELEASE(s->pVertexBuffer);
	SAFE_RELEASE(s->pSpriteBufferBackground);
	SAFE_RELEASE(s->pSpriteBufferCarres);
	SAFE_RELEASE(s->pSpriteBufferSRVBackground);
	SAFE_RELEASE(s->pSpriteBufferSRVCarres);
	SAFE_RELEASE(s->pConstantBuffer);
	SAFE_RELEASE(s->pInputLayout);
	SAFE_RELEASE(s->pVertexShader);
	SAFE_RELEASE(s->pPixelShader);
 
	SAFE_RELEASE(pBackground);
	SAFE_RELEASE(pCarres);
 
	SAFE_RELEASE(pSrvBackground);
	SAFE_RELEASE(pSrvCarres);
 
	SAFE_RELEASE(pSampler);
 
	delete s;
	delete spritesBackground;
	delete spritesCarres;
}
 
void WINAPI OnKeyboard(UINT nChar, bool bKeyDown, bool bAltDown, void* pUserContext) {
	Scene &maScene = *static_cast<Scene*>(pUserContext);
	D3DXMATRIX M1, M2, M3;
	D3DXMATRIX mWorldTmp;
	D3DXVECTOR3 coordObj;
	if( bKeyDown ) {
		switch( nChar ) {
			case VK_DOWN:
				//D3DXMatrixTranslation(&M3,0.0f,-0.1f,0.0f);
				//spritesCarres->getData()->pos.y = spritesCarres->getData()->pos.y - 0.1;
				spritesCarres->setPosY_Sprite(spritesCarres->getPosY_Sprite(0)-2, 0);
				spritesCarres->setPosY_Sprite(spritesCarres->getPosY_Sprite(1)-2, 1);
				spritesCarres->setPosY_Sprite(spritesCarres->getPosY_Sprite(2)-2, 2);
				spritesCarres->setPosY_Sprite(spritesCarres->getPosY_Sprite(3)-2, 3);
				//constBuf.setMatrix(M3);
				break;
			case VK_UP:
				D3DXMatrixRotationZ(&M3,D3DXToRadian(90));
 
				spritesCarres->setMatrice(M3, 0);
 
				break;
			case VK_LEFT:
				spritesCarres->setPosX_Sprite(spritesCarres->getPosX_Sprite(0)+2, 0);
				spritesCarres->setPosX_Sprite(spritesCarres->getPosX_Sprite(1)+2, 1);
				spritesCarres->setPosX_Sprite(spritesCarres->getPosX_Sprite(2)+2, 2);
				spritesCarres->setPosX_Sprite(spritesCarres->getPosX_Sprite(3)+2, 3);
				break;
			case VK_RIGHT:
				spritesCarres->setPosX_Sprite(spritesCarres->getPosX_Sprite(0)+2, 0);
				spritesCarres->setPosX_Sprite(spritesCarres->getPosX_Sprite(1)+2, 1);
				spritesCarres->setPosX_Sprite(spritesCarres->getPosX_Sprite(2)+2, 2);
				spritesCarres->setPosX_Sprite(spritesCarres->getPosX_Sprite(3)+2, 3);
				break;
		} 
	}
}
 
 
INT WINAPI WinMain( HINSTANCE hInstuuyyyyuuy, HINSTANCE hPrevInst, LPSTR, int ) {
	// environnement principal
	Scene	*scene = new Scene();
 
	OpenConsole(80,1000);
 
	// pointeur vers les fonctions
	DXUTSetCallbackD3D11DeviceCreated( OnCreateDevice, scene );
	DXUTSetCallbackFrameMove( OnFrameMove, scene );
    DXUTSetCallbackD3D11FrameRender( OnFrameRender, scene );
    DXUTSetCallbackD3D11DeviceDestroyed( OnDestroyDevice, scene );
	DXUTSetCallbackKeyboard( OnKeyboard, scene );
	// initialialisation et boucle principale
	DXUTInit();
    DXUTCreateWindow( L"Demo" );
	DXUTCreateDevice( D3D_FEATURE_LEVEL_11_0, true, 800, 600 );
    DXUTMainLoop();
 
	CloseConsole();
 
    return DXUTGetExitCode();
}

shader.fx :

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
#pragma pack_matrix(row_major)
 
struct Sprite{
	matrix		matrice;
	float3		pos;
	float2		uv,size;
	float2		redim;
	float		scale;
};
 
cbuffer constantBuffer{
	matrix MWorld;
	//matrix rotate;
};
 
Texture2D t : register (t0);
SamplerState s : register(s0);
StructuredBuffer<Sprite> SpriteTable:register(t0);
 
Texture2D tileSet1:register(t1);
Texture2D textBackground:register(t2);
Texture2D skins:register(t3);
 
SamplerState sampler1:register(s0);
 
struct VSin {
	float2 pos: POSITION;
};
 
struct VSout {
	float4 pos: SV_POSITION;
	float2 uv : TEXCOORD;
};
 
VSout VSmain( VSin Vin, uint Pid:SV_InstanceID ) {
	VSout Vout = (VSout)0;	
	Sprite S = SpriteTable[Pid];
 
	//float newX = (Vin.pos.x + S.pos.x) *0.025;
	//float newY = (Vin.pos.y + S.pos.y) *0.03125;
	float newX = (Vin.pos.x + S.pos.x) * S.redim.x;
	float newY = (Vin.pos.y + S.pos.y) * S.redim.y;
	float newZ = S.pos.z;
	//float newX = (Vin.pos.x + S.pos.x);
	//float newY = (Vin.pos.y + S.pos.y);
	float2 P = float2(newX, newY);
	////Vout.pos = mul(float4( P, newZ, 1 ), MWorld);
	Vout.pos = mul(float4( P, newZ, 1 ), S.matrice);
	Vout.uv = S.uv + (Vin.pos+1.f)/2 * S.size;
 
	return Vout;
};
 
struct PSin {
	float4 pos: SV_POSITION;
	float2 uv:TEXCOORD;
};
 
float4 PSmain( PSin P ) : SV_Target { 
	return t.Sample(s, P.uv);
	//return color;
	//return float4(1,0,0,1);
};

sprite.h :

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
#ifndef _SPRITE_
#define _SPRITE_
#include "Structure.h"
 
class Sprite{
	private :
 
		int N;
		int dataSize;
		Sprite_struct *data;
 
		/*D3DXVECTOR2 m_positionQuad;
		D3DXVECTOR2 m_positionTexture;
		D3DXVECTOR2 m_size;
		float m_scale;*/
 
	public :
 
		Sprite(int size);
		~Sprite();
		int getN();
		Sprite_struct* getData();
		int getDataSize();
		void add(D3DXVECTOR3 pos,float scale, D3DXVECTOR2 uv, D3DXVECTOR2 size,D3DXVECTOR2 redim, D3DXMATRIX matrice);
 
		void setPosSprite(D3DXVECTOR3, int);
 
		void setPosX_Sprite(float, int);
		float getPosX_Sprite(int);
		void setPosY_Sprite(float, int);
		float getPosY_Sprite(int);
		void setPosZ_Sprite(float, int);
		float getPosZ_Sprite(int);
 
		void setMatrice(D3DXMATRIX, int);
		D3DXMATRIX getMatrice(int);
 
		/*Sprite();
		Sprite(D3DXVECTOR2, D3DXVECTOR2, D3DXVECTOR2, float);
 
		D3DXVECTOR2 getPositionQuad();
		void setPositionQuad(D3DXVECTOR2);
 
		D3DXVECTOR2 getPositionTexture();
		void setPositionTexture(D3DXVECTOR2);
 
		D3DXVECTOR2 getSize();
		void setSize(D3DXVECTOR2);
 
		float getScale();
		void setScale(float);*/
};
 
#endif

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
sprite.cpp :
 
#include <Windows.h>
#include <d3d11.h>
#include <d3dx11.h>
#include <DxErr.h>
#include <DXUT.h>
#include "ConstantBuffer.h"
#include "Sprite.h"
 
//-------------------COSNTRUCTEURS----------------//
/*Sprite::Sprite(){
	m_positionQuad = D3DXVECTOR2(0.5f, 0.5f);
	m_positionTexture = D3DXVECTOR2(0.0f, 0.0f);
	m_size = D3DXVECTOR2(0.5f, 0.5f);
	m_scale = 1;
}
 
Sprite::Sprite(D3DXVECTOR2 newPosQuad, D3DXVECTOR2 newPosTex, D3DXVECTOR2 newSize, float newScale){
	m_positionQuad = newPosQuad;
	m_positionTexture = newPosTex;
	m_size = newSize;
	m_scale = newScale;
}
 
//---------------------GETTERS ET SETTERS---------------//
D3DXVECTOR2 Sprite::getPositionQuad(){
	return m_positionQuad;
}
 
void Sprite::setPositionQuad(D3DXVECTOR2 newPosQuad){
	m_positionQuad = newPosQuad;
}
 
D3DXVECTOR2 Sprite::getPositionTexture(){
	return m_positionTexture;
}
 
void Sprite::setPositionTexture(D3DXVECTOR2 newPosTex){
	m_positionTexture = newPosTex;
}
 
D3DXVECTOR2 Sprite::getSize(){
	return m_size;
}
 
void Sprite::setSize(D3DXVECTOR2 newSize){
	m_size = newSize;
}
 
float Sprite::getScale(){
	return m_scale;
}
 
void Sprite::setScale(float newScale){
	m_scale = newScale;
}*/
 
 
 
 
 
 
 
 
Sprite::Sprite(int size){
	data = new Sprite_struct[size];
	N = 0;
}
 
Sprite::~Sprite(void){
	delete data;
}
 
Sprite_struct* Sprite::getData(){
	return data;
}
 
int Sprite::getN(){
	return N;
}
 
int Sprite::getDataSize(){
	return sizeof(Sprite_struct)*N;
}
 
void Sprite::setPosSprite(D3DXVECTOR3 newPos, int numSprite){
	data[numSprite].pos = newPos;
}
 
void Sprite::setPosX_Sprite(float newPos, int numSprite){
	data[numSprite].pos.x = newPos;
}
 
float Sprite::getPosX_Sprite(int numSprite){
	return data[numSprite].pos.x;
}
 
void Sprite::setPosY_Sprite(float newPos, int numSprite){
	data[numSprite].pos.y = newPos;
}
 
float Sprite::getPosY_Sprite(int numSprite){
	return data[numSprite].pos.y;
}
 
void Sprite::setPosZ_Sprite(float newPos, int numSprite){
	data[numSprite].pos.z = newPos;
}
 
float Sprite::getPosZ_Sprite(int numSprite){
	return data[numSprite].pos.z;
}
 
void Sprite::setMatrice(D3DXMATRIX newMatrice, int numSprite){
	data[numSprite].matrice = newMatrice;
}
 
D3DXMATRIX Sprite::getMatrice(int numSprite){
	return data[numSprite].matrice;
}
 
void Sprite::add(D3DXVECTOR3 pos,float scale, D3DXVECTOR2 uv,D3DXVECTOR2 size, D3DXVECTOR2 newRedim, D3DXMATRIX newMatrice){
	data[N].pos=pos;
	data[N].scale=scale;
	data[N].uv=uv;
	data[N].size=size;
	data[N].redim = newRedim;
	data[N].matrice = newMatrice;
	N++;
}

structure.h :

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
#pragma once
#include <d3dx9math.h>
#include <d3d11.h>
 
struct Sprite_struct{
	D3DXMATRIX matrice;
	D3DXVECTOR3	pos;
	D3DXVECTOR2	uv,size;
	D3DXVECTOR2 redim;
	float scale;
};
 
struct Scene {
	ID3D11Buffer				*pVertexBuffer;
	ID3D11Buffer				*pSpriteBufferBackground;
	ID3D11Buffer				*pSpriteBufferCarres;
	ID3D11Buffer				*pConstantBuffer;
	ID3D11ShaderResourceView	*pSpriteBufferSRVBackground;
	ID3D11ShaderResourceView	*pSpriteBufferSRVCarres;
	ID3D11InputLayout			*pInputLayout;
	ID3D11VertexShader			*pVertexShader;
	ID3D11PixelShader			*pPixelShader;
	Scene() { memset(this,0,sizeof(Scene)); };
};

et mon constantBuffer.h:

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
#ifndef _CONSTANTBUFFER_
#define _CONSTANTBUFFER_
#include <Windows.h>
#include <d3d11.h>
#include <d3dx11.h>
#include <DxErr.h>
#include <DXUT.h>
 
class ConstantBuffer{
 
	private :
 
		D3DXMATRIX m_MWorld;
		//D3DXMATRIX m_rotation;
 
	public :
 
		ConstantBuffer();
		ConstantBuffer( D3DXMATRIX );
 
		void setMatrix( D3DXMATRIX );
		D3DXMATRIX getMatrix();
 
};
 
#endif

Si vous en êtes arrivez là dans mon messagen je vous remercie infiniment d'avoir lu. Et si vous arrivez à m'aider, je vous remercie d'avantage

Bonne continuation.

**LittleWhite** · 20/03/2012, 20h51

Bonjour,

Pour le problème de rotation, je pense que cela dépend de l'ordre dans lequel vous effectuez les transformations.
Essayez d'intervertir la rotation avec la translation. Sinon, pouvez vous juste coller le code des transformations pour les pièces uniquement (que je repère rapidement ce que vous faites).

Qu'est ce qu'un "buffer structuré" ?

Aide pour mon application "tetris"

DirectX

Discussions similaires

Partager

Partager