Problème d'application de texture

**paladice** · 14/03/2012, 13h00

Bonjour à tous,

je suis en train d'essayer de faire un petit tetris avec directx 11 et DXUT.
Pour l'instant j'ouvre simplement une fenêtre, je crée un quad qui recevra un texture et je veux l'afficher.
Cependant, l'affichage que je veux obtenir ne me convient pas. J'ai l'impression que :
soit je ne vais pas chercher la texture correctement
soit elle ne se redimensionne pas bien avec mon quad.

Voici mon fichier que j'utilise comme texture (je sais c'est chrono trigger, ça n'a rien a voir avec tetris mais c'est juste pour le test) :
http://img15.hostingpics.net/pics/745139test.png

Ensuite, voici les sources de mon code (il n'y a pas grand chose

) :

main.cc :

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
#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"
#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 = 50000;
 
Sprite *elementsScene = new Sprite[NB_ELTS];
 
struct Scene {
	ID3D11InputLayout *pInputLayout;
	ID3D11VertexShader *pVertexShader;
	ID3D11Buffer * pVertexBuffer;
	ID3D11PixelShader *pPixelShader;
	ID3D11Buffer * pSpriteBuffer;
	ID3D11ShaderResourceView * textureView;
	ID3D11ShaderResourceView * spriteView;
 
	ConstantBuffer m_cBufferCPU;
	ID3D11Buffer * m_cBufferGPU;
 
	Scene() { memset(this,0,sizeof(Scene)); };
};
 
HRESULT WINAPI OnCreateDevice(ID3D11Device *device, CONST DXGI_SURFACE_DESC * pBackBufferSurfaceDesc, void* pUserContext) {
	Scene &s = *static_cast<Scene*>(pUserContext);
 
	// -----------------------------VERTEX BUFFER--------------------------------------------------------------------//
	D3DXVECTOR2 caraObjet[4] = {D3DXVECTOR2(-0.1f,0.1f), D3DXVECTOR2(0.1f,0.1f), D3DXVECTOR2(-0.1f,-0.1f), D3DXVECTOR2(0.1f,-0.1f)};
	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-----------------------------------------//
	D3D11_BUFFER_DESC BufDesc = CD3D11_BUFFER_DESC(	2*sizeof(Sprite), 
													D3D11_BIND_SHADER_RESOURCE, 
													D3D11_USAGE_DYNAMIC, 
													D3D11_CPU_ACCESS_WRITE, 
													D3D11_RESOURCE_MISC_BUFFER_STRUCTURED, 
													sizeof(Sprite));
	device->CreateBuffer(&BufDesc, NULL, &s.pSpriteBuffer);
	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 = 2;
	device->CreateShaderResourceView(s.pSpriteBuffer, &srvd, &s.spriteView );
 
	// ------------------------------------------------------------TEXTURE VIEW---------------------------------//
	ID3D11Resource * ressourceTmp;
	ID3D11Texture2D * textureTmp;
	D3DX11CreateTextureFromFileA(device, "test.png", NULL, NULL, &ressourceTmp, NULL);
	ressourceTmp->QueryInterface(__uuidof(ID3D11Texture2D),(void**)&textureTmp );
	device->CreateShaderResourceView(textureTmp, NULL, &s.textureView);
	SAFE_RELEASE(ressourceTmp);
	SAFE_RELEASE(textureTmp);
 
	//------------------------------- CONSTANT BUFFER---------------------//
	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.m_cBufferGPU);
 
	// -----------------------------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);
 
	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);
	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;
 
	//-------------------------CONSTANT BUFFER ----------------------------------//
	ID3D11Buffer * constantBufferGPUTmp;
	constantBufferGPUTmp = s.m_cBufferGPU;
	ConstantBuffer constantBufferCPUTmp;
 
	ID3D11Buffer *pCBnull = NULL;
	HRESULT h;
	D3D11_MAPPED_SUBRESOURCE Mapped;
	context->VSSetConstantBuffers(0, 1, &pCBnull);
	context->PSSetConstantBuffers(0, 1, &pCBnull);
	// mise à jour du buffer de constantes
	h = context->Map(constantBufferGPUTmp, 0, D3D11_MAP_WRITE_DISCARD, 0, &Mapped);
	CopyMemory(Mapped.pData, &constantBufferCPUTmp, sizeof(ConstantBuffer) );
	context->Unmap(constantBufferGPUTmp, 0);
	// réattache le buffer de constante du pipeline
	context->VSSetConstantBuffers(0, 1, &constantBufferGPUTmp);
	context->PSSetConstantBuffers(0, 1, &constantBufferGPUTmp);
 
 
	// ----------------------------SAMPLER-----------------------------//
	ID3D11SamplerState *pSS = NULL;
	CD3D11_DEFAULT parDefaut;
	CD3D11_SAMPLER_DESC sd(parDefaut);
	sd.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
	sd.AddressU = sd.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
	device->CreateSamplerState( &sd, &pSS );
	// affectation de l'état au pipeline
	context->VSSetSamplers( 0, 1, &pSS );
	context->PSSetSamplers( 0, 1, &pSS );
 
	ID3D11Buffer * vertexBufferTmp;
	vertexBufferTmp = s.pVertexBuffer;
 
	//--------------------------Dans la boucle---------------------------//
 
	//Attachement view sur texture avec PixelShader
	context->PSSetShaderResources(0,1,&s.textureView); // affecte les slots de 0 à 1
 
	Sprite mesSprites[2];
 
	Sprite spriteObjet(	D3DXVECTOR2(0.0f, 0.0f),
						D3DXVECTOR2(0.0f, 1.0f),
						D3DXVECTOR2(1.f/12.f, 1.f/8.f),
						1);
 
	Sprite spriteObjetDeux(	D3DXVECTOR2(0.4f, 0.4f),
							D3DXVECTOR2(0.f, 1.f),
							D3DXVECTOR2(1.f/12.f, 1.f/8.f),
							1);
	mesSprites[0] = spriteObjet;
	mesSprites[1] = spriteObjetDeux;
 
	// mise à jour du buffer structuré
	ID3D11ShaderResourceView *NoRes=NULL;
	context->VSSetShaderResources(0,1,&NoRes);
	context->Map(s.pSpriteBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &Mapped);
	CopyMemory(Mapped.pData,&mesSprites,sizeof(Sprite)*2); //2 = nombre de sprites à dessiner
	context->Unmap(s.pSpriteBuffer, 0);
	// configuration du pipeline
	{ 
	UINT stride=sizeof(D3DXVECTOR2), offset=0;
	context->VSSetShaderResources(0,1,&s.spriteView);
	context->IASetVertexBuffers(0,1,&s.pVertexBuffer,&stride,&offset);
	context->IASetInputLayout(s.pInputLayout);
	context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
	context->VSSetShader(s.pVertexShader,NULL,0);
	context->PSSetShader(s.pPixelShader,NULL,0);
	context->DrawInstanced(4,2,0,0);
	}
 
	SAFE_RELEASE(pSS);
 
}
 
 
void WINAPI OnDestroyDevice(void* pUserContext) {
	Scene *s = static_cast<Scene*>(pUserContext);
	// devrait être dans le destructeur
	SAFE_RELEASE(s->pInputLayout);
	SAFE_RELEASE(s->pVertexShader);
	SAFE_RELEASE(s->pPixelShader);
	SAFE_RELEASE(s->pVertexBuffer);
	SAFE_RELEASE(s->pSpriteBuffer);
	SAFE_RELEASE(s->textureView);
	SAFE_RELEASE(s->spriteView);
	SAFE_RELEASE(s->m_cBufferGPU);
	delete s;
}
 
void WINAPI OnKeyboard(UINT nChar, bool bKeyDown, bool bAltDown, void* pUserContext) {
	Scene &maScene = *static_cast<Scene*>(pUserContext);
	D3DXMATRIX M1, M2, M3;
	D3DXMATRIX mWorldTmp;
	if( bKeyDown ) {
		switch( nChar ) {
			case '1':
				//WriteConsole("appuiesur1");
				//maScene.mesObjets[0].setColorConstantBufferCPU(D3DXVECTOR4(0.f,1.f,0.f,1.f));
				//maScene.mesObjets[1].setColorConstantBufferCPU(D3DXVECTOR4(1.f,1.f,0.f,1.f));
				break;
			case '2': 
				//maScene.mesObjets[0].setColorConstantBufferCPU(D3DXVECTOR4(0.f,1.f,1.f,1.f));
				//maScene.mesObjets[1].setColorConstantBufferCPU(D3DXVECTOR4(1.f,1.f,1.f,1.f));
				break;
			case '3':
				//maScene.mesObjets[0].setColorConstantBufferCPU(D3DXVECTOR4(1.f,1.f,0.f,1.f));
				//maScene.mesObjets[1].setColorConstantBufferCPU(D3DXVECTOR4(1.f,0.f,0.f,1.f));
				break;
			case VK_DOWN:
				//D3DXMatrixTranslation(&M3,0.0f,-0.1f,0.0f);
				//D3DXMatrixMultiply(&mWorldTmp,&maScene.mesObjets[0].getConstantBufferCPU().getMatrix(),&M3);
				//maScene.mesObjets[0].setMatrixConstantBufferCPU(mWorldTmp);
				break;
			case VK_UP:
				D3DXMatrixRotationZ(&M3,D3DXToRadian(90));
				maScene.m_cBufferCPU.setMatrix(M3);
				//maScene.mesObjets[0].setMatrixConstantBufferCPU(mWorldTmp);
				break;
			case VK_LEFT:
				//D3DXMatrixTranslation(&M3,-0.1f,0.0f,0.0f);
				//D3DXMatrixMultiply(&mWorldTmp,&maScene.mesObjets[0].getConstantBufferCPU().getMatrix(),&M3);
				//maScene.mesObjets[0].setMatrixConstantBufferCPU(mWorldTmp);
				break;
			case VK_RIGHT:
				//D3DXMatrixTranslation(&M3,0.1f,0.0f,0.0f);
				//D3DXMatrixMultiply(&mWorldTmp,&maScene.mesObjets[0].getConstantBufferCPU().getMatrix(),&M3);
				//maScene.mesObjets[0].setMatrixConstantBufferCPU(mWorldTmp);
				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
#pragma pack_matrix(row_major)
 
struct Sprite {
	float2 positionQuad;
	float2 uv;
	float2 size;
	float scale;
};
 
cbuffer constantBuffer{
	matrix MWorld;
	//matrix rotate;
};
 
Texture2D t : register (t0);
SamplerState s : register(s0);
StructuredBuffer<Sprite> SpriteTable:register(t0);
//tbuffer SpriteTable:register(t0) {
	//Sprite	sss[2];
//}
 
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];
 
	//float2 scale = S.scale * float2(1,S.size.y/S.size.x);
	//float2 P = S.positionQuad + mul( MWorld , (Vin.pos - 0.5)*scale );
	//Vout.pos = float4( P.x, -P.y, 0, 1);
	Vout.pos = mul(float4( Vin.pos + S.positionQuad, 0, 1 ), MWorld);
	Vout.uv = S.uv + Vin.pos * 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);
};

et mes petites classes

:

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

ConstantBuffer.cc

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
#include <Windows.h>
#include <d3d11.h>
#include <d3dx11.h>
#include <DxErr.h>
#include <DXUT.h>
#include "ConstantBuffer.h"
 
ConstantBuffer::ConstantBuffer(){
	m_MWorld = D3DXMATRIX(	1,0,0,0,
							0,1,0,0,
							0,0,1,0,
							0,0,0,1);
	//D3DXMatrixRotationZ(&m_rotation,D3DXToRadian(180));
}
 
ConstantBuffer::ConstantBuffer( D3DXMATRIX newMatrix){
	m_MWorld = newMatrix;
}
 
void ConstantBuffer::setMatrix( D3DXMATRIX newMatrix){
	m_MWorld = newMatrix;
}
 
D3DXMATRIX ConstantBuffer::getMatrix(){
	return m_MWorld;
}

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
#ifndef _SPRITE_
#define _SPRITE_
 
class Sprite{
	private :
 
		D3DXVECTOR2 m_positionQuad;
		D3DXVECTOR2 m_positionTexture;
		D3DXVECTOR2 m_size;
		float m_scale;
 
	public :
 
		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

Sprite.cc :

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
#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;
}