Debian Codegraph @

src/win/d3d_shader.cpp

raw
1 /* ______ ___ ___
2 * /\ _ \ /\_ \ /\_ \
3 * \ \ \L\ \\//\ \ \//\ \ __ __ _ __ ___
4 * \ \ __ \ \ \ \ \ \ \ /'__`\ /'_ `\/\`'__\/ __`\
5 * \ \ \/\ \ \_\ \_ \_\ \_/\ __//\ \L\ \ \ \//\ \L\ \
6 * \ \_\ \_\/\____\/\____\ \____\ \____ \ \_\\ \____/
7 * \/_/\/_/\/____/\/____/\/____/\/___L\ \/_/ \/___/
8 * /\____/
9 * \_/__/
10 *
11 * Direct3D shader support.
12 *
13 * See LICENSE.txt for copyright information.
14 */
15
16 #include "allegro5/allegro.h"
17 #include "allegro5/allegro_direct3d.h"
18 #include "allegro5/internal/aintern.h"
19 #include "allegro5/internal/aintern_bitmap.h"
20 #include "allegro5/internal/aintern_display.h"
21 #include "allegro5/internal/aintern_direct3d.h"
22 #include "allegro5/internal/aintern_shader.h"
23
24 #include <d3dx9.h>
25
26 #include "d3d.h"
27
28 ALLEGRO_DEBUG_CHANNEL("shader")
29
30 #ifdef ALLEGRO_CFG_SHADER_HLSL
31
32 static _AL_VECTOR shaders;
33
34 struct ALLEGRO_SHADER_HLSL_S
35 {
36 ALLEGRO_SHADER shader;
37 LPD3DXEFFECT hlsl_shader;
38 int shader_model;
39 };
40
41 static const char *null_source = "";
42
43 static const char *technique_source_vertex_v2 =
44 "technique TECH\n"
45 "{\n"
46 " pass p1\n"
47 " {\n"
48 " VertexShader = compile vs_2_0 vs_main();\n"
49 " PixelShader = null;\n"
50 " }\n"
51 "}\n";
52
53 static const char *technique_source_pixel_v2 =
54 "technique TECH\n"
55 "{\n"
56 " pass p1\n"
57 " {\n"
58 " VertexShader = null;\n"
59 " PixelShader = compile ps_2_0 ps_main();\n"
60 " }\n"
61 "}\n\n";
62
63 static const char *technique_source_both_v2 =
64 "technique TECH\n"
65 "{\n"
66 " pass p1\n"
67 " {\n"
68 " VertexShader = compile vs_2_0 vs_main();\n"
69 " PixelShader = compile ps_2_0 ps_main();\n"
70 " }\n"
71 "}\n";
72
73 static const char *technique_source_vertex_v3 =
74 "technique TECH\n"
75 "{\n"
76 " pass p1\n"
77 " {\n"
78 " VertexShader = compile vs_3_0 vs_main();\n"
79 " PixelShader = null;\n"
80 " }\n"
81 "}\n";
82
83 static const char *technique_source_pixel_v3 =
84 "technique TECH\n"
85 "{\n"
86 " pass p1\n"
87 " {\n"
88 " VertexShader = null;\n"
89 " PixelShader = compile ps_3_0 ps_main();\n"
90 " }\n"
91 "}\n\n";
92
93 static const char *technique_source_both_v3 =
94 "technique TECH\n"
95 "{\n"
96 " pass p1\n"
97 " {\n"
98 " VertexShader = compile vs_3_0 vs_main();\n"
99 " PixelShader = compile ps_3_0 ps_main();\n"
100 " }\n"
101 "}\n";
102
103
104 static bool hlsl_attach_shader_source(ALLEGRO_SHADER *shader,
105 ALLEGRO_SHADER_TYPE type, const char *source);
106 static bool hlsl_build_shader(ALLEGRO_SHADER *shader);
107 static bool hlsl_use_shader(ALLEGRO_SHADER *shader, ALLEGRO_DISPLAY *display,
108 bool set_projview_matrix_from_display);
109 static void hlsl_unuse_shader(ALLEGRO_SHADER *shader, ALLEGRO_DISPLAY *display);
110 static void hlsl_destroy_shader(ALLEGRO_SHADER *shader);
111 static void hlsl_on_lost_device(ALLEGRO_SHADER *shader);
112 static void hlsl_on_reset_device(ALLEGRO_SHADER *shader);
113 static bool hlsl_set_shader_sampler(ALLEGRO_SHADER *shader,
114 const char *name, ALLEGRO_BITMAP *bitmap, int unit);
115 static bool hlsl_set_shader_matrix(ALLEGRO_SHADER *shader,
116 const char *name, const ALLEGRO_TRANSFORM *matrix);
117 static bool hlsl_set_shader_int(ALLEGRO_SHADER *shader,
118 const char *name, int i);
119 static bool hlsl_set_shader_float(ALLEGRO_SHADER *shader,
120 const char *name, float f);
121 static bool hlsl_set_shader_int_vector(ALLEGRO_SHADER *shader,
122 const char *name, int num_components, const int *i, int num_elems);
123 static bool hlsl_set_shader_float_vector(ALLEGRO_SHADER *shader,
124 const char *name, int num_components, const float *f, int num_elems);
125 static bool hlsl_set_shader_bool(ALLEGRO_SHADER *shader,
126 const char *name, bool b);
127
128 static struct ALLEGRO_SHADER_INTERFACE shader_hlsl_vt =
129 {
130 hlsl_attach_shader_source,
131 hlsl_build_shader,
132 hlsl_use_shader,
133 hlsl_unuse_shader,
134 hlsl_destroy_shader,
135 hlsl_on_lost_device,
136 hlsl_on_reset_device,
137 hlsl_set_shader_sampler,
138 hlsl_set_shader_matrix,
139 hlsl_set_shader_int,
140 hlsl_set_shader_float,
141 hlsl_set_shader_int_vector,
142 hlsl_set_shader_float_vector,
143 hlsl_set_shader_bool
144 };
145
146 void _al_d3d_on_lost_shaders(ALLEGRO_DISPLAY *display)
147 {
148 unsigned i;
149 (void)display;
150
151 for (i = 0; i < _al_vector_size(&shaders); i++) {
152 ALLEGRO_SHADER **shader = (ALLEGRO_SHADER **)_al_vector_ref(&shaders, i);
153 (*shader)->vt->on_lost_device(*shader);
154 }
155 }
156
157 void _al_d3d_on_reset_shaders(ALLEGRO_DISPLAY *display)
158 {
159 unsigned i;
160 (void)display;
161
162 for (i = 0; i < _al_vector_size(&shaders); i++) {
163 ALLEGRO_SHADER **shader = (ALLEGRO_SHADER **)_al_vector_ref(&shaders, i);
164 (*shader)->vt->on_reset_device(*shader);
165 }
166 }
167
168 ALLEGRO_SHADER *_al_create_shader_hlsl(ALLEGRO_SHADER_PLATFORM platform, int shader_model)
169 {
170 ALLEGRO_SHADER_HLSL_S *shader;
171
172 if (NULL == _al_imp_D3DXCreateEffect) {
173 ALLEGRO_ERROR("D3DXCreateEffect unavailable\n");
174 return NULL;
175 }
176
177 shader = (ALLEGRO_SHADER_HLSL_S *)al_calloc(1, sizeof(ALLEGRO_SHADER_HLSL_S));
178 if (!shader)
179 return NULL;
180 shader->shader.platform = platform;
181 shader->shader.vt = &shader_hlsl_vt;
182 shader->shader_model = shader_model;
183 _al_vector_init(&shader->shader.bitmaps, sizeof(ALLEGRO_BITMAP *));
184
185 // For simplicity, these fields are never NULL in this backend.
186 shader->shader.pixel_copy = al_ustr_new("");
187 shader->shader.vertex_copy = al_ustr_new("");
188
189 ALLEGRO_SHADER **back = (ALLEGRO_SHADER **)_al_vector_alloc_back(&shaders);
190 *back = (ALLEGRO_SHADER *)shader;
191
192 _al_add_display_invalidated_callback(al_get_current_display(), _al_d3d_on_lost_shaders);
193 _al_add_display_validated_callback(al_get_current_display(), _al_d3d_on_reset_shaders);
194
195 return (ALLEGRO_SHADER *)shader;
196 }
197
198 static bool hlsl_attach_shader_source(ALLEGRO_SHADER *shader,
199 ALLEGRO_SHADER_TYPE type, const char *source)
200 {
201 bool add_technique;
202 ALLEGRO_USTR *full_source;
203 LPD3DXBUFFER errors;
204 const char *vertex_source, *pixel_source, *technique_source;
205 ALLEGRO_SHADER_HLSL_S *hlsl_shader = (ALLEGRO_SHADER_HLSL_S *)shader;
206 ALLEGRO_DISPLAY *display = al_get_current_display();
207 ASSERT(display);
208 ASSERT(display->flags & ALLEGRO_DIRECT3D);
209
210 if (source == NULL) {
211 if (type == ALLEGRO_VERTEX_SHADER) {
212 if (shader->vertex_copy) {
213 al_ustr_truncate(shader->vertex_copy, 0);
214 hlsl_shader->hlsl_shader->Release();
215 }
216 vertex_source = null_source;
217 pixel_source = al_cstr(shader->pixel_copy);
218 }
219 else {
220 if (shader->pixel_copy) {
221 al_ustr_truncate(shader->pixel_copy, 0);
222 hlsl_shader->hlsl_shader->Release();
223 }
224 pixel_source = null_source;
225 vertex_source = al_cstr(shader->vertex_copy);
226 }
227 }
228 else {
229 if (type == ALLEGRO_VERTEX_SHADER) {
230 vertex_source = source;
231 al_ustr_truncate(shader->vertex_copy, 0);
232 al_ustr_append_cstr(shader->vertex_copy, vertex_source);
233 pixel_source = al_cstr(shader->pixel_copy);
234 }
235 else {
236 pixel_source = source;
237 al_ustr_truncate(shader->pixel_copy, 0);
238 al_ustr_append_cstr(shader->pixel_copy, pixel_source);
239 vertex_source = al_cstr(shader->vertex_copy);
240 }
241 }
242
243 if (vertex_source[0] == 0 && pixel_source[0] == 0) {
244 return false;
245 }
246
247 if (strstr(vertex_source, "technique") || strstr(pixel_source, "technique"))
248 add_technique = false;
249 else
250 add_technique = true;
251
252 if (hlsl_shader->shader_model == 3) {
253 if (add_technique) {
254 if (vertex_source[0] == 0) {
255 technique_source = technique_source_pixel_v3;
256 }
257 else if (pixel_source[0] == 0) {
258 technique_source = technique_source_vertex_v3;
259 }
260 else {
261 technique_source = technique_source_both_v3;
262 }
263 }
264 else {
265 technique_source = null_source;
266 }
267 }
268 else {
269 if (add_technique) {
270 if (vertex_source[0] == 0) {
271 technique_source = technique_source_pixel_v2;
272 }
273 else if (pixel_source[0] == 0) {
274 technique_source = technique_source_vertex_v2;
275 }
276 else {
277 technique_source = technique_source_both_v2;
278 }
279 }
280 else {
281 technique_source = null_source;
282 }
283 }
284
285 // HLSL likes the source in one buffer
286 full_source = al_ustr_newf("%s\n#line 1\n%s\n%s\n",
287 vertex_source, pixel_source, technique_source);
288
289 // Release the shader if we already created it
290 if (hlsl_shader->hlsl_shader)
291 hlsl_shader->hlsl_shader->Release();
292
293 DWORD ok = _al_imp_D3DXCreateEffect(
294 al_get_d3d_device(display),
295 al_cstr(full_source),
296 al_ustr_size(full_source),
297 NULL,
298 NULL,
299 D3DXSHADER_PACKMATRIX_ROWMAJOR,
300 NULL,
301 &hlsl_shader->hlsl_shader,
302 &errors
303 );
304
305 al_ustr_free(full_source);
306
307 if (ok != D3D_OK) {
308 hlsl_shader->hlsl_shader = NULL;
309 char *msg = (char *)errors->GetBufferPointer();
310 if (shader->log) {
311 al_ustr_truncate(shader->log, 0);
312 al_ustr_append_cstr(shader->log, msg);
313 } else {
314 shader->log = al_ustr_new(msg);
315 }
316 ALLEGRO_ERROR("Error: %s\n", msg);
317 return false;
318 }
319
320 D3DXHANDLE hTech;
321 hTech = hlsl_shader->hlsl_shader->GetTechniqueByName("TECH");
322 hlsl_shader->hlsl_shader->ValidateTechnique(hTech);
323 hlsl_shader->hlsl_shader->SetTechnique(hTech);
324
325 return true;
326 }
327
328 static bool hlsl_build_shader(ALLEGRO_SHADER *shader)
329 {
330 (void)shader;
331 return true;
332 }
333
334 static bool hlsl_use_shader(ALLEGRO_SHADER *shader, ALLEGRO_DISPLAY *display,
335 bool set_projview_matrix_from_display)
336 {
337 ALLEGRO_SHADER_HLSL_S *hlsl_shader = (ALLEGRO_SHADER_HLSL_S *)shader;
338 LPD3DXEFFECT effect = hlsl_shader->hlsl_shader;
339 ALLEGRO_DISPLAY_D3D *d3d_disp;
340
341 if (!(display->flags & ALLEGRO_DIRECT3D)) {
342 return false;
343 }
344 d3d_disp = (ALLEGRO_DISPLAY_D3D *)display;
345
346 if (set_projview_matrix_from_display) {
347 if (!_al_hlsl_set_projview_matrix(effect, &display->projview_transform)) {
348 d3d_disp->effect = NULL;
349 return false;
350 }
351 }
352
353 d3d_disp->effect = hlsl_shader->hlsl_shader;
354 return true;
355 }
356
357 static void hlsl_unuse_shader(ALLEGRO_SHADER *shader, ALLEGRO_DISPLAY *display)
358 {
359 ALLEGRO_DISPLAY_D3D *d3d_disp = (ALLEGRO_DISPLAY_D3D *)display;
360
361 (void)shader;
362 //effect->EndPass();
363 //effect->End();
364 d3d_disp->effect = NULL;
365 }
366
367 static void hlsl_destroy_shader(ALLEGRO_SHADER *shader)
368 {
369 ALLEGRO_SHADER_HLSL_S *hlsl_shader = (ALLEGRO_SHADER_HLSL_S *)shader;
370
371 if (hlsl_shader->hlsl_shader)
372 hlsl_shader->hlsl_shader->Release();
373
374 _al_vector_find_and_delete(&shaders, &shader);
375
376 al_free(shader);
377 }
378
379 static void hlsl_on_lost_device(ALLEGRO_SHADER *shader)
380 {
381 ALLEGRO_SHADER_HLSL_S *hlsl_shader = (ALLEGRO_SHADER_HLSL_S *)shader;
382 hlsl_shader->hlsl_shader->OnLostDevice();
383 }
384
385 static void hlsl_on_reset_device(ALLEGRO_SHADER *shader)
386 {
387 ALLEGRO_SHADER_HLSL_S *hlsl_shader = (ALLEGRO_SHADER_HLSL_S *)shader;
388 hlsl_shader->hlsl_shader->OnResetDevice();
389 }
390
391 static bool hlsl_set_shader_sampler(ALLEGRO_SHADER *shader,
392 const char *name, ALLEGRO_BITMAP *bitmap, int unit)
393 {
394 ALLEGRO_SHADER_HLSL_S *hlsl_shader = (ALLEGRO_SHADER_HLSL_S *)shader;
395 HRESULT result;
396
397 if (al_get_bitmap_flags(bitmap) & ALLEGRO_MEMORY_BITMAP)
398 return false;
399
400 LPDIRECT3DTEXTURE9 vid_texture = al_get_d3d_video_texture(bitmap);
401 result = hlsl_shader->hlsl_shader->SetTexture(name, vid_texture);
402 ALLEGRO_DISPLAY_D3D *d3d_disp = (ALLEGRO_DISPLAY_D3D *)_al_get_bitmap_display(bitmap);
403 d3d_disp->device->SetTexture(unit, vid_texture);
404 _al_set_d3d_sampler_state(d3d_disp->device, unit, bitmap, false);
405
406 return result == D3D_OK;
407 }
408
409 static bool hlsl_set_shader_matrix(ALLEGRO_SHADER *shader,
410 const char *name, const ALLEGRO_TRANSFORM *matrix)
411 {
412 ALLEGRO_SHADER_HLSL_S *hlsl_shader = (ALLEGRO_SHADER_HLSL_S *)shader;
413 HRESULT result;
414
415 D3DXMATRIX m;
416
417 memcpy(m.m, matrix->m, sizeof(float)*16);
418
419 result = hlsl_shader->hlsl_shader->SetMatrix(name, &m);
420
421 return result == D3D_OK;
422 }
423
424 static bool hlsl_set_shader_int(ALLEGRO_SHADER *shader,
425 const char *name, int i)
426 {
427 ALLEGRO_SHADER_HLSL_S *hlsl_shader = (ALLEGRO_SHADER_HLSL_S *)shader;
428 HRESULT result;
429
430 result = hlsl_shader->hlsl_shader->SetInt(name, i);
431
432 return result == D3D_OK;
433 }
434
435 static bool hlsl_set_shader_float(ALLEGRO_SHADER *shader,
436 const char *name, float f)
437 {
438 ALLEGRO_SHADER_HLSL_S *hlsl_shader = (ALLEGRO_SHADER_HLSL_S *)shader;
439 HRESULT result;
440
441 result = hlsl_shader->hlsl_shader->SetFloat(name, f);
442
443 return result == D3D_OK;
444 }
445
446 static bool hlsl_set_shader_int_vector(ALLEGRO_SHADER *shader,
447 const char *name, int num_components, const int *i, int num_elems)
448 {
449 ALLEGRO_SHADER_HLSL_S *hlsl_shader = (ALLEGRO_SHADER_HLSL_S *)shader;
450 HRESULT result;
451
452 result = hlsl_shader->hlsl_shader->SetIntArray(name, i,
453 num_components * num_elems);
454
455 return result == D3D_OK;
456 }
457
458 static bool hlsl_set_shader_float_vector(ALLEGRO_SHADER *shader,
459 const char *name, int num_components, const float *f, int num_elems)
460 {
461 ALLEGRO_SHADER_HLSL_S *hlsl_shader = (ALLEGRO_SHADER_HLSL_S *)shader;
462 HRESULT result;
463
464 result = hlsl_shader->hlsl_shader->SetFloatArray(name, f,
465 num_components * num_elems);
466
467 return result == D3D_OK;
468 }
469
470 static bool hlsl_set_shader_bool(ALLEGRO_SHADER *shader,
471 const char *name, bool b)
472 {
473 ALLEGRO_SHADER_HLSL_S *hlsl_shader = (ALLEGRO_SHADER_HLSL_S *)shader;
474 HRESULT result;
475
476 result = hlsl_shader->hlsl_shader->SetBool(name, b);
477
478 return result == D3D_OK;
479 }
480
481 bool _al_hlsl_set_projview_matrix(
482 LPD3DXEFFECT effect, const ALLEGRO_TRANSFORM *t)
483 {
484 HRESULT result = effect->SetMatrix(ALLEGRO_SHADER_VAR_PROJVIEW_MATRIX,
485 (LPD3DXMATRIX)t->m);
486 return result == D3D_OK;
487 }
488
489 void _al_d3d_init_shaders(void)
490 {
491 _al_vector_init(&shaders, sizeof(ALLEGRO_SHADER *));
492 }
493
494 void _al_d3d_shutdown_shaders(void)
495 {
496 _al_vector_free(&shaders);
497 }
498
499 #endif
500
501 /* vim: set sts=3 sw=3 et: */