Discussion :

[vmfa-2 sven]

bonjour à tous,

voila, à l'aide de visual studio, j'ai réussi à créer une fenêtre assez facilement ( projet win32). Mon programme me permet de calculer une image. Cette image à une certaine résolution. J'ai stoker la couleur de chaque pixel dans un tableau.

J'aimerais savoir si quelqu'un connait une fonction qui me permet d'imposer la couleur d'un pixel donné de ma fenêtre. Merci d'avance!!

[Mat.M]

Salut d'abord utilises-tu Direct X ?
Si tu appelles le GDI donc pas Direct X, il ya des fonctions GDI pour cela avec StretchDIBbits() voir le MSDN.
Si tu appelles Direct X tu peux utiliser une IDirect3DSurface9 et appeler
IDirect3DSurface9::LockRect() pour dessiner pixel par pixel
Avec Direct X 10 c'est IDXGIDevice::CreateSurface() et une IDXGISurface
Mais sous Direct X 10 tu peux appeler tout de même les interfaces de D3d9 c'est plus simple.
Pour faire quelque chose de + sophistiqué il faut utiliser le langage HLSL et pixel shaders

[vmfa-2 sven]

En fait, la fenêtre crée est celle par défaut par visual studio. je met le code juste en dessous :

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
 
// RaytracingEngine.cpp*: définit le point d'entrée pour l'application.
//
 
#include "stdafx.h"
#include "RaytracingEngine.h"
 
#define MAX_LOADSTRING 100
 
// Variables globales*:
HINSTANCE hInst;								// instance actuelle
TCHAR szTitle[MAX_LOADSTRING];					// Le texte de la barre de titre
TCHAR szWindowClass[MAX_LOADSTRING];			// le nom de la classe de fenêtre principale
 
// Pré-déclarations des fonctions incluses dans ce module de code*:
ATOM				MyRegisterClass(HINSTANCE hInstance);
BOOL				InitInstance(HINSTANCE, int);
LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK	About(HWND, UINT, WPARAM, LPARAM);
 
int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,LPTSTR    lpCmdLine,int       nCmdShow)
{
	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpCmdLine);
 
 	// TODO*: placez ici le code.///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
	MSG msg;
	HACCEL hAccelTable;
 
	// Initialise les chaînes globales
	LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
	LoadString(hInstance, IDC_RAYTRACINGENGINE, szWindowClass, MAX_LOADSTRING);
	MyRegisterClass(hInstance);
 
	// Effectue l'initialisation de l'application*:
	if (!InitInstance (hInstance, nCmdShow))
	{
		return FALSE;
	}
 
	hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_RAYTRACINGENGINE));
 
	// Boucle de messages principale*:
	while (GetMessage(&msg, NULL, 0, 0))
	{
		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}
 
	return (int) msg.wParam;
}
 
 
 
//
//  FONCTION*: MyRegisterClass()
//
//  BUT*: inscrit la classe de fenêtre.
//
//  COMMENTAIRES*:
//
//    Cette fonction et son utilisation sont nécessaires uniquement si vous souhaitez que ce code
//    soit compatible avec les systèmes Win32 avant la fonction 'RegisterClassEx'
//    qui a été ajoutée à Windows*95. Il est important d'appeler cette fonction
//    afin que l'application dispose des petites icônes correctes qui lui sont
//    associées.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
	WNDCLASSEX wcex;
 
	wcex.cbSize = sizeof(WNDCLASSEX);
 
	wcex.style			= CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc	= WndProc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= 0;
	wcex.hInstance		= hInstance;
	wcex.hIcon			= LoadIcon(hInstance, MAKEINTRESOURCE(IDI_RAYTRACINGENGINE));
	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
	wcex.lpszMenuName	= MAKEINTRESOURCE(IDC_RAYTRACINGENGINE);
	wcex.lpszClassName	= szWindowClass;
	wcex.hIconSm		= LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
 
	return RegisterClassEx(&wcex);
}
 
//
//   FONCTION*: InitInstance(HINSTANCE, int)
//
//   BUT*: enregistre le handle de l'instance et crée une fenêtre principale
//
//   COMMENTAIRES*:
//
//        Dans cette fonction, nous enregistrons le handle de l'instance dans une variable globale, puis
//        créons et affichons la fenêtre principale du programme.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;
 
   hInst = hInstance; // Stocke le handle d'instance dans la variable globale
 
   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
 
   if (!hWnd)
   {
      return FALSE;
   }
 
   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);
 
   return TRUE;
}
 
//
//  FONCTION*: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  BUT*:  traite les messages pour la fenêtre principale.
//
//  WM_COMMAND	- traite le menu de l'application
//  WM_PAINT	- dessine la fenêtre principale
//  WM_DESTROY	- génère un message d'arrêt et retourne
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	int wmId, wmEvent;
	PAINTSTRUCT ps;
	HDC hdc;
 
	switch (message)
	{
	case WM_COMMAND:
		wmId    = LOWORD(wParam);
		wmEvent = HIWORD(wParam);
		// Analyse les sélections de menu*:
		switch (wmId)
		{
		case IDM_ABOUT:
			DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
			break;
		case IDM_EXIT:
			DestroyWindow(hWnd);
			break;
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
		}
		break;
	case WM_PAINT:
		hdc = BeginPaint(hWnd, &ps);
 
		// TODO*: ajoutez ici le code de dessin...///////////////////////////////////////////////////////////////////////////////////////////////////////////
		//IDirect3DSurface9::LockRect()
 
		EndPaint(hWnd, &ps);
		break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}
 
// Gestionnaire de messages pour la boîte de dialogue À propos de.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	UNREFERENCED_PARAMETER(lParam);
	switch (message)
	{
	case WM_INITDIALOG:
		return (INT_PTR)TRUE;
 
	case WM_COMMAND:
		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
		{
			EndDialog(hDlg, LOWORD(wParam));
			return (INT_PTR)TRUE;
		}
		break;
	}
	return (INT_PTR)FALSE;
}

Si possible, j'aimerais pouvoir utiliser directX10 par l'affichage. Mais pour ma part, le plus simple serait le mieux.

[vmfa-2 sven]

voila, j'ai cherché un peu plus dans le sdk.

j'y ai trouvé la fonction suivante :

Code :

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

1
2
3
4
5
HRESULT LockRect(
  D3DLOCKED_RECT * pLockedRect,
  CONST RECT * pRect,
  DWORD Flags
);

J'ai bien sûr ajouté #include <D3D9.h>.

le seul souci ce sont les arguments de cette fonction, malgré les explications dans le sdk, j'ai du mal à la comprendre parfaitement.
le premier pLockedRect semble être un pointeur vers une structure??
le second , ben je sais pas.

le dernier ben il semble que j'ai le choix entre différentes option pour ceci.

Si quelqun peut m'éclairer un peu, ce serait sympa!

bonne journée.

[Mat.M]

Code :

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

1
2
3
4
5
6
7
8
9
 
case WM_PAINT:
		hdc = BeginPaint(hWnd, &ps);
 
		// TODO*: ajoutez ici le code de dessin...///////////////////////////////////////////////////////////////////////////////////////////////////////////
		//IDirect3DSurface9::LockRect()
 
		EndPaint(hWnd, &ps);
		break;

Pourquoi gères-tu WM_PAINT ?
WM_PAINT c'est pour les tracés GDI.
Tu obtiens un hdc un contexte de périphérique graphique qui te permet de dessiner des lignes par exemple avec LineTo ( HDC,x,y) ou bien dessiner des points avec SetPixel( HDC,x,y,COLORREF).

Ici tu veux dessiner avec D3d9 donc il ne faut surtout pas gérer WM_PAINT !

Il faut que tu appelles un pipeline de rendu avec un D3dDevice :: BeginScene() et EndScene().

Je te conseille de prendre un bon bouquin d'initiation à direct 3d ou un bon tutoriel.

Pour Lock_rect il faut télécharger le SDK de Direct X.

Ensuite tu veux faire un raytracer, Direct3D ne te sera pas de grande utilité....parce que de toute façon tu vas utiliser la carte graphique pour l'accélèration matérielle mais pendant que le CPU fera des calculs pour tracer la scène, calculer les éclairages etc.. le GPU va attendre....
Donc je conseillerais de commencer avec le GDI bêtement..
Je crois que Le Greg a fait un tuto sur le raytracing.
Fais-une recherche sur ce forum il intervient souvent ici.

Ce que je peux conseiller c'est commencer bêtement avec SetPixel qui n'est pas terrible mais plus facile à utiliser que StretchDIBBits() ou autre.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
COLORREF couleur_pixel;
case WM_PAINT:
hdc=BeginPaint(hwnd,&ps);
for(int y=0;y<largeur_scene;y++)
{
for(int x=0;x<largeur_scene;x++)
{
 couleur_pixel=raytrace(x,y);
SetPixel(x,y,RGB(couleur_pixel);
}
EndPaint(hwnd,&ps);
}
break;

Faire un raytracer c'est complexe il faut partager la charge de calculs éventuellements sur plusieurs threads c'est de l'amusement en perspective

[vmfa-2 sven]

le fait d'utiliser direct3d est simplement pour pouvoir afficher directement l'image dans une fenêtre au lieu de générer à chaque fois un fichier image. ( tga ou bmp par exemple). Seulement, j'avais encore jamais toucher à directx ou opengl. ( j'aime pas vraiment ca en fait :-)).
Comme je cherche la solution la plus simple possible, je vais me concentrer sur la fonction setpixel que tu viens de me montrer. Je vais voir comment je peux l'utiliser dans le sdk.

Faire un raytracer c'est complexe il faut partager la charge de calculs éventuellements sur plusieurs threads c'est de l'amusement en perspective

C'est exactement un des principaux buts de ce petit projet. C'est pour ça que je cherche le moyen le plus facile pour vite me débarrasser de la partie affichage à fin de me concentrer sur le plus important

[Mat.M]

Comme je cherche la solution la plus simple possible, je vais me concentrer sur la fonction setpixel que tu viens de me montrer. Je vais voir comment je peux l'utiliser dans le sdk.

Attention c'est pas dans le SDK de Direct X qu'il faut regarder mais dans le MSDN