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