OpenCPN Partial API docs
Loading...
Searching...
No Matches
pi_shaders.cpp
Go to the documentation of this file.
1/***************************************************************************
2 * Copyright (C) 2017 by David S. Register *
3 * *
4 * This program is free software; you can redistribute it and/or modify *
5 * it under the terms of the GNU General Public License as published by *
6 * the Free Software Foundation; either version 2 of the License, or *
7 * (at your option) any later version. *
8 * *
9 * This program is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12 * GNU General Public License for more details. *
13 * *
14 * You should have received a copy of the GNU General Public License *
15 * along with this program; if not, write to the *
16 * Free Software Foundation, Inc., *
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
18 **************************************************************************/
23#include "pi_shaders.h"
24
25#include "linmath.h"
26
27#ifdef USE_ANDROID_GLES2
28#include "qdebug.h"
29#include <GLES2/gl2.h>
30#endif
31
32#ifdef USE_ANDROID_GLES2
33const GLchar* PI_shader_preamble = "\n";
34#else
35const GLchar* PI_shader_preamble =
36 "#version 120\n"
37 "#define precision\n"
38 "#define lowp\n"
39 "#define mediump\n"
40 "#define highp\n";
41#endif
42
43// Simple colored triangle shader
44
45static const GLchar* color_tri_vertex_shader_source =
46 "attribute vec2 position;\n"
47 "uniform mat4 MVMatrix;\n"
48 "uniform mat4 TransformMatrix;\n"
49 "uniform vec4 color;\n"
50 "varying vec4 fragColor;\n"
51 "void main() {\n"
52 " fragColor = color;\n"
53 " gl_Position = MVMatrix * TransformMatrix * vec4(position, 0.0, 1.0);\n"
54 "}\n";
55
56static const GLchar* color_tri_fragment_shader_source =
57 "precision lowp float;\n"
58 "varying vec4 fragColor;\n"
59 "void main() {\n"
60 " gl_FragColor = fragColor;\n"
61 "}\n";
62
63// Array colored triangle shader
64static const GLchar* colorv_tri_vertex_shader_source =
65 "attribute vec2 position;\n"
66 "attribute vec4 colorv;\n"
67 "uniform mat4 MVMatrix;\n"
68 "uniform mat4 TransformMatrix;\n"
69 "varying vec4 fragColor;\n"
70 "void main() {\n"
71 " fragColor = colorv;\n"
72 " gl_Position = MVMatrix * TransformMatrix * vec4(position, 0.0, 1.0);\n"
73 "}\n";
74
75static const GLchar* colorv_tri_fragment_shader_source =
76 "precision lowp float;\n"
77 "varying vec4 fragColor;\n"
78 "void main() {\n"
79 " gl_FragColor = fragColor;\n"
80 "}\n";
81
82// Simple 2D texture shader
83static const GLchar* texture_2D_vertex_shader_source =
84 "attribute vec2 aPos;\n"
85 "attribute vec2 aUV;\n"
86 "uniform mat4 MVMatrix;\n"
87 "uniform mat4 TransformMatrix;\n"
88 "varying vec2 varCoord;\n"
89 "void main() {\n"
90 " gl_Position = MVMatrix * TransformMatrix * vec4(aPos, 0.0, 1.0);\n"
91 " varCoord = aUV;\n"
92 "}\n";
93
94static const GLchar* texture_2D_fragment_shader_source =
95 "precision lowp float;\n"
96 "uniform sampler2D uTex;\n"
97 "varying vec2 varCoord;\n"
98 "void main() {\n"
99 " gl_FragColor = texture2D(uTex, varCoord);\n"
100 "}\n";
101
102// Fade Texture shader
103static const GLchar* fade_texture_2D_vertex_shader_source =
104 "precision highp float;\n"
105 "attribute vec2 aPos;\n"
106 "attribute vec2 aUV;\n"
107 "attribute vec2 aUV2;\n"
108 "uniform mat4 MVMatrix;\n"
109 "varying vec2 varCoord;\n"
110 "varying vec2 varCoord2;\n"
111 "void main() {\n"
112 " gl_Position = MVMatrix * vec4(aPos, 0.0, 1.0);\n"
113 " varCoord = aUV.st;\n"
114 " varCoord2 = aUV2.st;\n"
115 "}\n";
116
117static const GLchar* fade_texture_2D_fragment_shader_source =
118 "precision highp float;\n"
119 "uniform sampler2D uTex;\n"
120 "uniform sampler2D uTex2;\n"
121 "uniform lowp float texAlpha;\n"
122 "varying vec2 varCoord;\n"
123 "varying vec2 varCoord2;\n"
124 "void main() {\n"
125 " mediump vec4 texColor = texture2D(uTex, varCoord);\n"
126 " mediump vec4 texTwoColor = texture2D(uTex2, varCoord2);\n"
127 " gl_FragColor = ((texTwoColor * (1.0 - texAlpha)) + (texColor * "
128 "texAlpha));\n"
129 "}\n";
130
131// Circle shader
132
133static const GLchar* circle_filled_vertex_shader_source =
134 "precision highp float;\n"
135 "attribute vec2 aPos;\n"
136 "uniform mat4 MVMatrix;\n"
137 "uniform mat4 TransformMatrix;\n"
138 "void main() {\n"
139 " gl_Position = MVMatrix * TransformMatrix * vec4(aPos, 0.0, 1.0);\n"
140 "}\n";
141
142static const GLchar* circle_filled_fragment_shader_source =
143 "precision highp float;\n"
144 "uniform float border_width;\n"
145 "uniform float circle_radius;\n"
146 "uniform vec4 circle_color;\n"
147 "uniform vec4 border_color;\n"
148 "uniform vec2 circle_center;\n"
149 "void main(){\n"
150 "float d = distance(gl_FragCoord.xy, circle_center);\n"
151 "if (d < (circle_radius - border_width)) { gl_FragColor = circle_color; }\n"
152 "else if (d < circle_radius) { gl_FragColor = border_color; }\n"
153 "else { gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0); }\n"
154 "}\n";
155
156// 2D texture shader for FBOs
157static const GLchar* FBO_texture_2D_vertex_shader_source =
158 "attribute vec2 aPos;\n"
159 "attribute vec2 aUV;\n"
160 "uniform mat4 MVMatrix;\n"
161 "varying vec2 varCoord;\n"
162 "void main() {\n"
163 " gl_Position = MVMatrix * vec4(aPos, 0.0, 1.0);\n"
164 " varCoord = aUV;\n"
165 "}\n";
166
167static const GLchar* FBO_texture_2D_fragment_shader_source =
168 "precision lowp float;\n"
169 "uniform sampler2D uTex;\n"
170 "varying vec2 varCoord;\n"
171 "void main() {\n"
172 " gl_FragColor = texture2D(uTex, varCoord);\n"
173 "}\n";
174
175GLint pi_color_tri_fragment_shader;
176GLint GRIBpi_color_tri_shader_program;
177GLint pi_color_tri_vertex_shader;
178
179GLint pi_colorv_tri_fragment_shader;
180GLint GRIBpi_colorv_tri_shader_program;
181GLint pi_colorv_tri_vertex_shader;
182
183GLint pi_texture_2D_fragment_shader;
184GLint pi_texture_2D_shader_program;
185GLint pi_texture_2D_vertex_shader;
186
187// GLint fade_texture_2D_fragment_shader;
188// GLint fade_texture_2D_shader_program;
189// GLint fade_texture_2D_vertex_shader;
190
191GLint pi_circle_filled_shader_program;
192GLint pi_circle_filled_vertex_shader;
193GLint pi_circle_filled_fragment_shader;
194
195// GLint FBO_texture_2D_fragment_shader;
196// GLint FBO_texture_2D_shader_program;
197// GLint FBO_texture_2D_vertex_shader;
198
199bool pi_loadShaders() {
200 bool ret_val = true;
201 GLint success;
202
203 enum Consts { INFOLOG_LEN = 512 };
204 GLchar infoLog[INFOLOG_LEN];
205
206 // Are the shaders ready?
207
208 // Simple colored triangle shader
209
210 if (!GRIBpi_color_tri_shader_program) {
211 auto shaderProgram =
212 PI_GLShaderProgram::Builder()
213 .addShaderFromSource(color_tri_vertex_shader_source,
214 GL_VERTEX_SHADER)
215 .addShaderFromSource(color_tri_fragment_shader_source,
216 GL_FRAGMENT_SHADER)
217 .linkProgram();
218
219 GRIBpi_color_tri_shader_program = shaderProgram.programId();
220 }
221
222#if 0
223 if (!pi_color_tri_vertex_shader) {
224 /* Vertex shader */
225 pi_color_tri_vertex_shader = glCreateShader(GL_VERTEX_SHADER);
226 glShaderSource(pi_color_tri_vertex_shader, 1,
227 &color_tri_vertex_shader_source, nullptr);
228 glCompileShader(pi_color_tri_vertex_shader);
229 glGetShaderiv(pi_color_tri_vertex_shader, GL_COMPILE_STATUS, &success);
230 if (!success) {
231 glGetShaderInfoLog(pi_color_tri_vertex_shader, INFOLOG_LEN, nullptr,
232 infoLog);
233 printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n%s\n", infoLog);
234 ret_val = false;
235 }
236 }
237
238 if (!pi_color_tri_fragment_shader) {
239 /* Fragment shader */
240 pi_color_tri_fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
241 glShaderSource(pi_color_tri_fragment_shader, 1,
242 &color_tri_fragment_shader_source, nullptr);
243 glCompileShader(pi_color_tri_fragment_shader);
244 glGetShaderiv(pi_color_tri_fragment_shader, GL_COMPILE_STATUS, &success);
245 if (!success) {
246 glGetShaderInfoLog(pi_color_tri_fragment_shader, INFOLOG_LEN, nullptr,
247 infoLog);
248 printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n%s\n", infoLog);
249 ret_val = false;
250 }
251 }
252
253 if (!pi_color_tri_shader_program) {
254 /* Link shaders */
255 pi_color_tri_shader_program = glCreateProgram();
256 glAttachShader(pi_color_tri_shader_program, pi_color_tri_fragment_shader);
257 glAttachShader(pi_color_tri_shader_program, pi_color_tri_vertex_shader);
258 glLinkProgram(pi_color_tri_shader_program);
259 glGetProgramiv(pi_color_tri_shader_program, GL_LINK_STATUS, &success);
260 if (!success) {
261 glGetProgramInfoLog(pi_color_tri_shader_program, INFOLOG_LEN, nullptr,
262 infoLog);
263 printf("ERROR::SHADER::PROGRAM::LINKING_FAILED\n%s\n", infoLog);
264 ret_val = false;
265 }
266 }
267#endif
268
269 // Array colored triangle shader
270 if (!GRIBpi_colorv_tri_shader_program) {
271 auto shaderProgram =
272 PI_GLShaderProgram::Builder()
273 .addShaderFromSource(colorv_tri_vertex_shader_source,
274 GL_VERTEX_SHADER)
275 .addShaderFromSource(colorv_tri_fragment_shader_source,
276 GL_FRAGMENT_SHADER)
277 .linkProgram();
278
279 GRIBpi_colorv_tri_shader_program = shaderProgram.programId();
280 }
281
282#if 0
283 if (!pi_colorv_tri_vertex_shader) {
284 /* Vertex shader */
285 pi_colorv_tri_vertex_shader = glCreateShader(GL_VERTEX_SHADER);
286 glShaderSource(pi_colorv_tri_vertex_shader, 1,
287 &colorv_tri_vertex_shader_source, nullptr);
288 glCompileShader(pi_colorv_tri_vertex_shader);
289 glGetShaderiv(pi_colorv_tri_vertex_shader, GL_COMPILE_STATUS, &success);
290 if (!success) {
291 glGetShaderInfoLog(pi_colorv_tri_vertex_shader, INFOLOG_LEN, nullptr,
292 infoLog);
293 printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n%s\n", infoLog);
294 ret_val = false;
295 }
296 }
297
298 if (!pi_colorv_tri_fragment_shader) {
299 /* Fragment shader */
300 pi_colorv_tri_fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
301 glShaderSource(pi_colorv_tri_fragment_shader, 1,
302 &colorv_tri_fragment_shader_source, nullptr);
303 glCompileShader(pi_colorv_tri_fragment_shader);
304 glGetShaderiv(pi_colorv_tri_fragment_shader, GL_COMPILE_STATUS, &success);
305 if (!success) {
306 glGetShaderInfoLog(pi_colorv_tri_fragment_shader, INFOLOG_LEN, nullptr,
307 infoLog);
308 printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n%s\n", infoLog);
309 ret_val = false;
310 }
311 }
312
313 if (!pi_colorv_tri_shader_program) {
314 /* Link shaders */
315 pi_colorv_tri_shader_program = glCreateProgram();
316 glAttachShader(pi_colorv_tri_shader_program, pi_colorv_tri_fragment_shader);
317 glAttachShader(pi_colorv_tri_shader_program, pi_colorv_tri_vertex_shader);
318 glLinkProgram(pi_colorv_tri_shader_program);
319 glGetProgramiv(pi_colorv_tri_shader_program, GL_LINK_STATUS, &success);
320 if (!success) {
321 glGetProgramInfoLog(pi_colorv_tri_shader_program, INFOLOG_LEN, nullptr,
322 infoLog);
323 printf("ERROR::SHADER::PROGRAM::LINKING_FAILED\n%s\n", infoLog);
324 ret_val = false;
325 }
326 }
327#endif
328
329 // Simple 2D texture shader
330 if (!pi_texture_2D_shader_program) {
331 auto shaderProgram =
332 PI_GLShaderProgram::Builder()
333 .addShaderFromSource(texture_2D_vertex_shader_source,
334 GL_VERTEX_SHADER)
335 .addShaderFromSource(texture_2D_fragment_shader_source,
336 GL_FRAGMENT_SHADER)
337 .linkProgram();
338
339 pi_texture_2D_shader_program = shaderProgram.programId();
340 }
341
342#if 0
343 if (!pi_texture_2D_vertex_shader) {
344 /* Vertex shader */
345 pi_texture_2D_vertex_shader = glCreateShader(GL_VERTEX_SHADER);
346 glShaderSource(pi_texture_2D_vertex_shader, 1,
347 &texture_2D_vertex_shader_source, nullptr);
348 glCompileShader(pi_texture_2D_vertex_shader);
349 glGetShaderiv(pi_texture_2D_vertex_shader, GL_COMPILE_STATUS, &success);
350 if (!success) {
351 glGetShaderInfoLog(pi_texture_2D_vertex_shader, INFOLOG_LEN, nullptr,
352 infoLog);
353 printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n%s\n", infoLog);
354 ret_val = false;
355 }
356 }
357
358 if (!pi_texture_2D_fragment_shader) {
359 /* Fragment shader */
360 pi_texture_2D_fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
361 glShaderSource(pi_texture_2D_fragment_shader, 1,
362 &texture_2D_fragment_shader_source, nullptr);
363 glCompileShader(pi_texture_2D_fragment_shader);
364 glGetShaderiv(pi_texture_2D_fragment_shader, GL_COMPILE_STATUS, &success);
365 if (!success) {
366 glGetShaderInfoLog(pi_texture_2D_fragment_shader, INFOLOG_LEN, nullptr,
367 infoLog);
368 printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n%s\n", infoLog);
369 ret_val = false;
370 }
371 }
372
373 if (!pi_texture_2D_shader_program) {
374 /* Link shaders */
375 pi_texture_2D_shader_program = glCreateProgram();
376 glAttachShader(pi_texture_2D_shader_program, pi_texture_2D_vertex_shader);
377 glAttachShader(pi_texture_2D_shader_program, pi_texture_2D_fragment_shader);
378 glLinkProgram(pi_texture_2D_shader_program);
379 glGetProgramiv(pi_texture_2D_shader_program, GL_LINK_STATUS, &success);
380 if (!success) {
381 glGetProgramInfoLog(pi_texture_2D_shader_program, INFOLOG_LEN, nullptr,
382 infoLog);
383 printf("ERROR::SHADER::PROGRAM::LINKING_FAILED\n%s\n", infoLog);
384 ret_val = false;
385 }
386 }
387#endif
388
389#if 0
390
391 // Fade texture shader
392 if(!fade_texture_2D_vertex_shader){
393 /* Vertex shader */
394 fade_texture_2D_vertex_shader = glCreateShader(GL_VERTEX_SHADER);
395 glShaderSource(fade_texture_2D_vertex_shader, 1, &fade_texture_2D_vertex_shader_source, nullptr);
396 glCompileShader(fade_texture_2D_vertex_shader);
397 glGetShaderiv(fade_texture_2D_vertex_shader, GL_COMPILE_STATUS, &success);
398 if (!success) {
399 glGetShaderInfoLog(fade_texture_2D_vertex_shader, INFOLOG_LEN, nullptr, infoLog);
400 printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n%s\n", infoLog);
401 ret_val = false;
402 }
403 }
404
405 if(!fade_texture_2D_fragment_shader){
406 /* Fragment shader */
407 fade_texture_2D_fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
408 glShaderSource(fade_texture_2D_fragment_shader, 1, &fade_texture_2D_fragment_shader_source, nullptr);
409 glCompileShader(fade_texture_2D_fragment_shader);
410 glGetShaderiv(fade_texture_2D_fragment_shader, GL_COMPILE_STATUS, &success);
411 if (!success) {
412 glGetShaderInfoLog(fade_texture_2D_fragment_shader, INFOLOG_LEN, nullptr, infoLog);
413 printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n%s\n", infoLog);
414 ret_val = false;
415 }
416 }
417
418 if(!fade_texture_2D_shader_program){
419 /* Link shaders */
420 fade_texture_2D_shader_program = glCreateProgram();
421 glAttachShader(fade_texture_2D_shader_program, fade_texture_2D_vertex_shader);
422 glAttachShader(fade_texture_2D_shader_program, fade_texture_2D_fragment_shader);
423 glLinkProgram(fade_texture_2D_shader_program);
424 glGetProgramiv(fade_texture_2D_shader_program, GL_LINK_STATUS, &success);
425 if (!success) {
426 glGetProgramInfoLog(fade_texture_2D_shader_program, INFOLOG_LEN, nullptr, infoLog);
427 printf("ERROR::SHADER::PROGRAM::LINKING_FAILED\n%s\n", infoLog);
428 ret_val = false;
429 }
430 }
431
432#endif
433
434 // Circle shader
435 if (!pi_circle_filled_shader_program) {
436 auto shaderProgram =
437 PI_GLShaderProgram::Builder()
438 .addShaderFromSource(circle_filled_vertex_shader_source,
439 GL_VERTEX_SHADER)
440 .addShaderFromSource(circle_filled_fragment_shader_source,
441 GL_FRAGMENT_SHADER)
442 .linkProgram();
443
444 pi_circle_filled_shader_program = shaderProgram.programId();
445 }
446
447#if 0
448 if (!pi_circle_filled_vertex_shader) {
449 /* Vertex shader */
450 pi_circle_filled_vertex_shader = glCreateShader(GL_VERTEX_SHADER);
451 glShaderSource(pi_circle_filled_vertex_shader, 1,
452 &circle_filled_vertex_shader_source, nullptr);
453 glCompileShader(pi_circle_filled_vertex_shader);
454 glGetShaderiv(pi_circle_filled_vertex_shader, GL_COMPILE_STATUS, &success);
455 if (!success) {
456 glGetShaderInfoLog(pi_circle_filled_vertex_shader, INFOLOG_LEN, nullptr,
457 infoLog);
458 printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n%s\n", infoLog);
459 //qDebug() << infoLog;
460 ret_val = false;
461 }
462 }
463
464 if (!pi_circle_filled_fragment_shader) {
465 /* Fragment shader */
466 pi_circle_filled_fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
467 glShaderSource(pi_circle_filled_fragment_shader, 1,
468 &circle_filled_fragment_shader_source, nullptr);
469 glCompileShader(pi_circle_filled_fragment_shader);
470 glGetShaderiv(pi_circle_filled_fragment_shader, GL_COMPILE_STATUS,
471 &success);
472 if (!success) {
473 glGetShaderInfoLog(pi_circle_filled_fragment_shader, INFOLOG_LEN, nullptr,
474 infoLog);
475 printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n%s\n", infoLog);
476 //qDebug() << infoLog;
477 ret_val = false;
478 }
479 }
480
481 if (!pi_circle_filled_shader_program) {
482 /* Link shaders */
483 pi_circle_filled_shader_program = glCreateProgram();
484 glAttachShader(pi_circle_filled_shader_program,
485 pi_circle_filled_vertex_shader);
486 glAttachShader(pi_circle_filled_shader_program,
487 pi_circle_filled_fragment_shader);
488 glLinkProgram(pi_circle_filled_shader_program);
489 glGetProgramiv(pi_circle_filled_shader_program, GL_LINK_STATUS, &success);
490 if (!success) {
491 glGetProgramInfoLog(pi_circle_filled_shader_program, INFOLOG_LEN, nullptr,
492 infoLog);
493 printf("ERROR::SHADER::PROGRAM::LINKING_FAILED\n%s\n", infoLog);
494 //qDebug() << infoLog;
495 ret_val = false;
496 }
497 }
498#endif
499
500#if 0
501 // FBO 2D texture shader
502
503 if(!FBO_texture_2D_vertex_shader){
504 /* Vertex shader */
505 FBO_texture_2D_vertex_shader = glCreateShader(GL_VERTEX_SHADER);
506 glShaderSource(FBO_texture_2D_vertex_shader, 1, &FBO_texture_2D_vertex_shader_source, nullptr);
507 glCompileShader(FBO_texture_2D_vertex_shader);
508 glGetShaderiv(FBO_texture_2D_vertex_shader, GL_COMPILE_STATUS, &success);
509 if (!success) {
510 glGetShaderInfoLog(FBO_texture_2D_vertex_shader, INFOLOG_LEN, nullptr, infoLog);
511 printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n%s\n", infoLog);
512 ret_val = false;
513 }
514 }
515
516 if(!FBO_texture_2D_fragment_shader){
517 /* Fragment shader */
518 FBO_texture_2D_fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
519 glShaderSource(FBO_texture_2D_fragment_shader, 1, &FBO_texture_2D_fragment_shader_source, nullptr);
520 glCompileShader(FBO_texture_2D_fragment_shader);
521 glGetShaderiv(FBO_texture_2D_fragment_shader, GL_COMPILE_STATUS, &success);
522 if (!success) {
523 glGetShaderInfoLog(FBO_texture_2D_fragment_shader, INFOLOG_LEN, nullptr, infoLog);
524 printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n%s\n", infoLog);
525 ret_val = false;
526 }
527 }
528
529 if(!FBO_texture_2D_shader_program){
530 /* Link shaders */
531 FBO_texture_2D_shader_program = glCreateProgram();
532 glAttachShader(FBO_texture_2D_shader_program, FBO_texture_2D_vertex_shader);
533 glAttachShader(FBO_texture_2D_shader_program, FBO_texture_2D_fragment_shader);
534 glLinkProgram(FBO_texture_2D_shader_program);
535 glGetProgramiv(FBO_texture_2D_shader_program, GL_LINK_STATUS, &success);
536 if (!success) {
537 glGetProgramInfoLog(FBO_texture_2D_shader_program, INFOLOG_LEN, nullptr, infoLog);
538 printf("ERROR::SHADER::PROGRAM::LINKING_FAILED\n%s\n", infoLog);
539 ret_val = false;
540 }
541 }
542#endif
543
544 // qDebug() << "pi_loadShaders: " << ret_val;
545 return ret_val;
546}
547
548void configureShaders(float width, float height) {
549 // Set the shader viewport transform matrix
550 float vp_transform[16];
551 mat4x4 m;
552 mat4x4_identity(m);
553 mat4x4_scale_aniso((float(*)[4])vp_transform, m, 2.0 / width, -2.0 / height,
554 1.0);
555 mat4x4_translate_in_place((float(*)[4])vp_transform, -width / 2, -height / 2,
556 0);
557
558 mat4x4 I;
559 mat4x4_identity(I);
560
561 glUseProgram(GRIBpi_color_tri_shader_program);
562 GLint matloc =
563 glGetUniformLocation(GRIBpi_color_tri_shader_program, "MVMatrix");
564 glUniformMatrix4fv(matloc, 1, GL_FALSE, (const GLfloat*)vp_transform);
565 GLint transloc =
566 glGetUniformLocation(GRIBpi_color_tri_shader_program, "TransformMatrix");
567 glUniformMatrix4fv(transloc, 1, GL_FALSE, (const GLfloat*)I);
568
569 // qDebug() << GRIBpi_color_tri_shader_program << transloc;
570
571 glUseProgram(pi_circle_filled_shader_program);
572 matloc = glGetUniformLocation(pi_circle_filled_shader_program, "MVMatrix");
573 glUniformMatrix4fv(matloc, 1, GL_FALSE, (const GLfloat*)vp_transform);
574 transloc =
575 glGetUniformLocation(pi_circle_filled_shader_program, "TransformMatrix");
576 glUniformMatrix4fv(transloc, 1, GL_FALSE, (const GLfloat*)I);
577
578 // qDebug() << pi_circle_filled_shader_program << transloc;
579
580 glUseProgram(pi_texture_2D_shader_program);
581 matloc = glGetUniformLocation(pi_texture_2D_shader_program, "MVMatrix");
582 glUniformMatrix4fv(matloc, 1, GL_FALSE, (const GLfloat*)vp_transform);
583 transloc =
584 glGetUniformLocation(pi_texture_2D_shader_program, "TransformMatrix");
585 glUniformMatrix4fv(transloc, 1, GL_FALSE, (const GLfloat*)I);
586
587 // qDebug() << pi_texture_2D_shader_program << transloc;
588
589 glUseProgram(GRIBpi_colorv_tri_shader_program);
590 matloc = glGetUniformLocation(GRIBpi_colorv_tri_shader_program, "MVMatrix");
591 glUniformMatrix4fv(matloc, 1, GL_FALSE, (const GLfloat*)vp_transform);
592 transloc =
593 glGetUniformLocation(GRIBpi_colorv_tri_shader_program, "TransformMatrix");
594 glUniformMatrix4fv(transloc, 1, GL_FALSE, (const GLfloat*)I);
595
596 glUseProgram(0);
597}
PI_GLShaderProgram::Builder
Definition pi_shaders.h:64