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 // Some platforms require explicit initialization of GLEW interface
207 // in the plugin module
208#if defined(__linux__) && defined(__OCPN_USE_GLEW__) && \
209 !defined(__ANDROID__) && !defined(__WXOSX)
210 auto GLEW_test = glCreateProgram; // this is (unsigned int(*)(void))
211 if (!GLEW_test) glewInit();
212#endif
213
214 // Are the shaders ready?
215
216 // Simple colored triangle shader
217
218 if (!GRIBpi_color_tri_shader_program) {
219 auto shaderProgram =
220 PI_GLShaderProgram::Builder()
221 .addShaderFromSource(color_tri_vertex_shader_source,
222 GL_VERTEX_SHADER)
223 .addShaderFromSource(color_tri_fragment_shader_source,
224 GL_FRAGMENT_SHADER)
225 .linkProgram();
226
227 GRIBpi_color_tri_shader_program = shaderProgram.programId();
228 }
229
230#if 0
231 if (!pi_color_tri_vertex_shader) {
232 /* Vertex shader */
233 pi_color_tri_vertex_shader = glCreateShader(GL_VERTEX_SHADER);
234 glShaderSource(pi_color_tri_vertex_shader, 1,
235 &color_tri_vertex_shader_source, nullptr);
236 glCompileShader(pi_color_tri_vertex_shader);
237 glGetShaderiv(pi_color_tri_vertex_shader, GL_COMPILE_STATUS, &success);
238 if (!success) {
239 glGetShaderInfoLog(pi_color_tri_vertex_shader, INFOLOG_LEN, nullptr,
240 infoLog);
241 printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n%s\n", infoLog);
242 ret_val = false;
243 }
244 }
245
246 if (!pi_color_tri_fragment_shader) {
247 /* Fragment shader */
248 pi_color_tri_fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
249 glShaderSource(pi_color_tri_fragment_shader, 1,
250 &color_tri_fragment_shader_source, nullptr);
251 glCompileShader(pi_color_tri_fragment_shader);
252 glGetShaderiv(pi_color_tri_fragment_shader, GL_COMPILE_STATUS, &success);
253 if (!success) {
254 glGetShaderInfoLog(pi_color_tri_fragment_shader, INFOLOG_LEN, nullptr,
255 infoLog);
256 printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n%s\n", infoLog);
257 ret_val = false;
258 }
259 }
260
261 if (!pi_color_tri_shader_program) {
262 /* Link shaders */
263 pi_color_tri_shader_program = glCreateProgram();
264 glAttachShader(pi_color_tri_shader_program, pi_color_tri_fragment_shader);
265 glAttachShader(pi_color_tri_shader_program, pi_color_tri_vertex_shader);
266 glLinkProgram(pi_color_tri_shader_program);
267 glGetProgramiv(pi_color_tri_shader_program, GL_LINK_STATUS, &success);
268 if (!success) {
269 glGetProgramInfoLog(pi_color_tri_shader_program, INFOLOG_LEN, nullptr,
270 infoLog);
271 printf("ERROR::SHADER::PROGRAM::LINKING_FAILED\n%s\n", infoLog);
272 ret_val = false;
273 }
274 }
275#endif
276
277 // Array colored triangle shader
278 if (!GRIBpi_colorv_tri_shader_program) {
279 auto shaderProgram =
280 PI_GLShaderProgram::Builder()
281 .addShaderFromSource(colorv_tri_vertex_shader_source,
282 GL_VERTEX_SHADER)
283 .addShaderFromSource(colorv_tri_fragment_shader_source,
284 GL_FRAGMENT_SHADER)
285 .linkProgram();
286
287 GRIBpi_colorv_tri_shader_program = shaderProgram.programId();
288 }
289
290#if 0
291 if (!pi_colorv_tri_vertex_shader) {
292 /* Vertex shader */
293 pi_colorv_tri_vertex_shader = glCreateShader(GL_VERTEX_SHADER);
294 glShaderSource(pi_colorv_tri_vertex_shader, 1,
295 &colorv_tri_vertex_shader_source, nullptr);
296 glCompileShader(pi_colorv_tri_vertex_shader);
297 glGetShaderiv(pi_colorv_tri_vertex_shader, GL_COMPILE_STATUS, &success);
298 if (!success) {
299 glGetShaderInfoLog(pi_colorv_tri_vertex_shader, INFOLOG_LEN, nullptr,
300 infoLog);
301 printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n%s\n", infoLog);
302 ret_val = false;
303 }
304 }
305
306 if (!pi_colorv_tri_fragment_shader) {
307 /* Fragment shader */
308 pi_colorv_tri_fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
309 glShaderSource(pi_colorv_tri_fragment_shader, 1,
310 &colorv_tri_fragment_shader_source, nullptr);
311 glCompileShader(pi_colorv_tri_fragment_shader);
312 glGetShaderiv(pi_colorv_tri_fragment_shader, GL_COMPILE_STATUS, &success);
313 if (!success) {
314 glGetShaderInfoLog(pi_colorv_tri_fragment_shader, INFOLOG_LEN, nullptr,
315 infoLog);
316 printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n%s\n", infoLog);
317 ret_val = false;
318 }
319 }
320
321 if (!pi_colorv_tri_shader_program) {
322 /* Link shaders */
323 pi_colorv_tri_shader_program = glCreateProgram();
324 glAttachShader(pi_colorv_tri_shader_program, pi_colorv_tri_fragment_shader);
325 glAttachShader(pi_colorv_tri_shader_program, pi_colorv_tri_vertex_shader);
326 glLinkProgram(pi_colorv_tri_shader_program);
327 glGetProgramiv(pi_colorv_tri_shader_program, GL_LINK_STATUS, &success);
328 if (!success) {
329 glGetProgramInfoLog(pi_colorv_tri_shader_program, INFOLOG_LEN, nullptr,
330 infoLog);
331 printf("ERROR::SHADER::PROGRAM::LINKING_FAILED\n%s\n", infoLog);
332 ret_val = false;
333 }
334 }
335#endif
336
337 // Simple 2D texture shader
338 if (!pi_texture_2D_shader_program) {
339 auto shaderProgram =
340 PI_GLShaderProgram::Builder()
341 .addShaderFromSource(texture_2D_vertex_shader_source,
342 GL_VERTEX_SHADER)
343 .addShaderFromSource(texture_2D_fragment_shader_source,
344 GL_FRAGMENT_SHADER)
345 .linkProgram();
346
347 pi_texture_2D_shader_program = shaderProgram.programId();
348 }
349
350#if 0
351 if (!pi_texture_2D_vertex_shader) {
352 /* Vertex shader */
353 pi_texture_2D_vertex_shader = glCreateShader(GL_VERTEX_SHADER);
354 glShaderSource(pi_texture_2D_vertex_shader, 1,
355 &texture_2D_vertex_shader_source, nullptr);
356 glCompileShader(pi_texture_2D_vertex_shader);
357 glGetShaderiv(pi_texture_2D_vertex_shader, GL_COMPILE_STATUS, &success);
358 if (!success) {
359 glGetShaderInfoLog(pi_texture_2D_vertex_shader, INFOLOG_LEN, nullptr,
360 infoLog);
361 printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n%s\n", infoLog);
362 ret_val = false;
363 }
364 }
365
366 if (!pi_texture_2D_fragment_shader) {
367 /* Fragment shader */
368 pi_texture_2D_fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
369 glShaderSource(pi_texture_2D_fragment_shader, 1,
370 &texture_2D_fragment_shader_source, nullptr);
371 glCompileShader(pi_texture_2D_fragment_shader);
372 glGetShaderiv(pi_texture_2D_fragment_shader, GL_COMPILE_STATUS, &success);
373 if (!success) {
374 glGetShaderInfoLog(pi_texture_2D_fragment_shader, INFOLOG_LEN, nullptr,
375 infoLog);
376 printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n%s\n", infoLog);
377 ret_val = false;
378 }
379 }
380
381 if (!pi_texture_2D_shader_program) {
382 /* Link shaders */
383 pi_texture_2D_shader_program = glCreateProgram();
384 glAttachShader(pi_texture_2D_shader_program, pi_texture_2D_vertex_shader);
385 glAttachShader(pi_texture_2D_shader_program, pi_texture_2D_fragment_shader);
386 glLinkProgram(pi_texture_2D_shader_program);
387 glGetProgramiv(pi_texture_2D_shader_program, GL_LINK_STATUS, &success);
388 if (!success) {
389 glGetProgramInfoLog(pi_texture_2D_shader_program, INFOLOG_LEN, nullptr,
390 infoLog);
391 printf("ERROR::SHADER::PROGRAM::LINKING_FAILED\n%s\n", infoLog);
392 ret_val = false;
393 }
394 }
395#endif
396
397#if 0
398
399 // Fade texture shader
400 if(!fade_texture_2D_vertex_shader){
401 /* Vertex shader */
402 fade_texture_2D_vertex_shader = glCreateShader(GL_VERTEX_SHADER);
403 glShaderSource(fade_texture_2D_vertex_shader, 1, &fade_texture_2D_vertex_shader_source, nullptr);
404 glCompileShader(fade_texture_2D_vertex_shader);
405 glGetShaderiv(fade_texture_2D_vertex_shader, GL_COMPILE_STATUS, &success);
406 if (!success) {
407 glGetShaderInfoLog(fade_texture_2D_vertex_shader, INFOLOG_LEN, nullptr, infoLog);
408 printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n%s\n", infoLog);
409 ret_val = false;
410 }
411 }
412
413 if(!fade_texture_2D_fragment_shader){
414 /* Fragment shader */
415 fade_texture_2D_fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
416 glShaderSource(fade_texture_2D_fragment_shader, 1, &fade_texture_2D_fragment_shader_source, nullptr);
417 glCompileShader(fade_texture_2D_fragment_shader);
418 glGetShaderiv(fade_texture_2D_fragment_shader, GL_COMPILE_STATUS, &success);
419 if (!success) {
420 glGetShaderInfoLog(fade_texture_2D_fragment_shader, INFOLOG_LEN, nullptr, infoLog);
421 printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n%s\n", infoLog);
422 ret_val = false;
423 }
424 }
425
426 if(!fade_texture_2D_shader_program){
427 /* Link shaders */
428 fade_texture_2D_shader_program = glCreateProgram();
429 glAttachShader(fade_texture_2D_shader_program, fade_texture_2D_vertex_shader);
430 glAttachShader(fade_texture_2D_shader_program, fade_texture_2D_fragment_shader);
431 glLinkProgram(fade_texture_2D_shader_program);
432 glGetProgramiv(fade_texture_2D_shader_program, GL_LINK_STATUS, &success);
433 if (!success) {
434 glGetProgramInfoLog(fade_texture_2D_shader_program, INFOLOG_LEN, nullptr, infoLog);
435 printf("ERROR::SHADER::PROGRAM::LINKING_FAILED\n%s\n", infoLog);
436 ret_val = false;
437 }
438 }
439
440#endif
441
442 // Circle shader
443 if (!pi_circle_filled_shader_program) {
444 auto shaderProgram =
445 PI_GLShaderProgram::Builder()
446 .addShaderFromSource(circle_filled_vertex_shader_source,
447 GL_VERTEX_SHADER)
448 .addShaderFromSource(circle_filled_fragment_shader_source,
449 GL_FRAGMENT_SHADER)
450 .linkProgram();
451
452 pi_circle_filled_shader_program = shaderProgram.programId();
453 }
454
455#if 0
456 if (!pi_circle_filled_vertex_shader) {
457 /* Vertex shader */
458 pi_circle_filled_vertex_shader = glCreateShader(GL_VERTEX_SHADER);
459 glShaderSource(pi_circle_filled_vertex_shader, 1,
460 &circle_filled_vertex_shader_source, nullptr);
461 glCompileShader(pi_circle_filled_vertex_shader);
462 glGetShaderiv(pi_circle_filled_vertex_shader, GL_COMPILE_STATUS, &success);
463 if (!success) {
464 glGetShaderInfoLog(pi_circle_filled_vertex_shader, INFOLOG_LEN, nullptr,
465 infoLog);
466 printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n%s\n", infoLog);
467 //qDebug() << infoLog;
468 ret_val = false;
469 }
470 }
471
472 if (!pi_circle_filled_fragment_shader) {
473 /* Fragment shader */
474 pi_circle_filled_fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
475 glShaderSource(pi_circle_filled_fragment_shader, 1,
476 &circle_filled_fragment_shader_source, nullptr);
477 glCompileShader(pi_circle_filled_fragment_shader);
478 glGetShaderiv(pi_circle_filled_fragment_shader, GL_COMPILE_STATUS,
479 &success);
480 if (!success) {
481 glGetShaderInfoLog(pi_circle_filled_fragment_shader, INFOLOG_LEN, nullptr,
482 infoLog);
483 printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n%s\n", infoLog);
484 //qDebug() << infoLog;
485 ret_val = false;
486 }
487 }
488
489 if (!pi_circle_filled_shader_program) {
490 /* Link shaders */
491 pi_circle_filled_shader_program = glCreateProgram();
492 glAttachShader(pi_circle_filled_shader_program,
493 pi_circle_filled_vertex_shader);
494 glAttachShader(pi_circle_filled_shader_program,
495 pi_circle_filled_fragment_shader);
496 glLinkProgram(pi_circle_filled_shader_program);
497 glGetProgramiv(pi_circle_filled_shader_program, GL_LINK_STATUS, &success);
498 if (!success) {
499 glGetProgramInfoLog(pi_circle_filled_shader_program, INFOLOG_LEN, nullptr,
500 infoLog);
501 printf("ERROR::SHADER::PROGRAM::LINKING_FAILED\n%s\n", infoLog);
502 //qDebug() << infoLog;
503 ret_val = false;
504 }
505 }
506#endif
507
508#if 0
509 // FBO 2D texture shader
510
511 if(!FBO_texture_2D_vertex_shader){
512 /* Vertex shader */
513 FBO_texture_2D_vertex_shader = glCreateShader(GL_VERTEX_SHADER);
514 glShaderSource(FBO_texture_2D_vertex_shader, 1, &FBO_texture_2D_vertex_shader_source, nullptr);
515 glCompileShader(FBO_texture_2D_vertex_shader);
516 glGetShaderiv(FBO_texture_2D_vertex_shader, GL_COMPILE_STATUS, &success);
517 if (!success) {
518 glGetShaderInfoLog(FBO_texture_2D_vertex_shader, INFOLOG_LEN, nullptr, infoLog);
519 printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n%s\n", infoLog);
520 ret_val = false;
521 }
522 }
523
524 if(!FBO_texture_2D_fragment_shader){
525 /* Fragment shader */
526 FBO_texture_2D_fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
527 glShaderSource(FBO_texture_2D_fragment_shader, 1, &FBO_texture_2D_fragment_shader_source, nullptr);
528 glCompileShader(FBO_texture_2D_fragment_shader);
529 glGetShaderiv(FBO_texture_2D_fragment_shader, GL_COMPILE_STATUS, &success);
530 if (!success) {
531 glGetShaderInfoLog(FBO_texture_2D_fragment_shader, INFOLOG_LEN, nullptr, infoLog);
532 printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n%s\n", infoLog);
533 ret_val = false;
534 }
535 }
536
537 if(!FBO_texture_2D_shader_program){
538 /* Link shaders */
539 FBO_texture_2D_shader_program = glCreateProgram();
540 glAttachShader(FBO_texture_2D_shader_program, FBO_texture_2D_vertex_shader);
541 glAttachShader(FBO_texture_2D_shader_program, FBO_texture_2D_fragment_shader);
542 glLinkProgram(FBO_texture_2D_shader_program);
543 glGetProgramiv(FBO_texture_2D_shader_program, GL_LINK_STATUS, &success);
544 if (!success) {
545 glGetProgramInfoLog(FBO_texture_2D_shader_program, INFOLOG_LEN, nullptr, infoLog);
546 printf("ERROR::SHADER::PROGRAM::LINKING_FAILED\n%s\n", infoLog);
547 ret_val = false;
548 }
549 }
550#endif
551
552 // qDebug() << "pi_loadShaders: " << ret_val;
553 return ret_val;
554}
555
556void configureShaders(float width, float height) {
557 // Set the shader viewport transform matrix
558 float vp_transform[16];
559 mat4x4 m;
560 mat4x4_identity(m);
561 mat4x4_scale_aniso((float(*)[4])vp_transform, m, 2.0 / width, -2.0 / height,
562 1.0);
563 mat4x4_translate_in_place((float(*)[4])vp_transform, -width / 2, -height / 2,
564 0);
565
566 mat4x4 I;
567 mat4x4_identity(I);
568
569 glUseProgram(GRIBpi_color_tri_shader_program);
570 GLint matloc =
571 glGetUniformLocation(GRIBpi_color_tri_shader_program, "MVMatrix");
572 glUniformMatrix4fv(matloc, 1, GL_FALSE, (const GLfloat*)vp_transform);
573 GLint transloc =
574 glGetUniformLocation(GRIBpi_color_tri_shader_program, "TransformMatrix");
575 glUniformMatrix4fv(transloc, 1, GL_FALSE, (const GLfloat*)I);
576
577 // qDebug() << GRIBpi_color_tri_shader_program << transloc;
578
579 glUseProgram(pi_circle_filled_shader_program);
580 matloc = glGetUniformLocation(pi_circle_filled_shader_program, "MVMatrix");
581 glUniformMatrix4fv(matloc, 1, GL_FALSE, (const GLfloat*)vp_transform);
582 transloc =
583 glGetUniformLocation(pi_circle_filled_shader_program, "TransformMatrix");
584 glUniformMatrix4fv(transloc, 1, GL_FALSE, (const GLfloat*)I);
585
586 // qDebug() << pi_circle_filled_shader_program << transloc;
587
588 glUseProgram(pi_texture_2D_shader_program);
589 matloc = glGetUniformLocation(pi_texture_2D_shader_program, "MVMatrix");
590 glUniformMatrix4fv(matloc, 1, GL_FALSE, (const GLfloat*)vp_transform);
591 transloc =
592 glGetUniformLocation(pi_texture_2D_shader_program, "TransformMatrix");
593 glUniformMatrix4fv(transloc, 1, GL_FALSE, (const GLfloat*)I);
594
595 // qDebug() << pi_texture_2D_shader_program << transloc;
596
597 glUseProgram(GRIBpi_colorv_tri_shader_program);
598 matloc = glGetUniformLocation(GRIBpi_colorv_tri_shader_program, "MVMatrix");
599 glUniformMatrix4fv(matloc, 1, GL_FALSE, (const GLfloat*)vp_transform);
600 transloc =
601 glGetUniformLocation(GRIBpi_colorv_tri_shader_program, "TransformMatrix");
602 glUniformMatrix4fv(transloc, 1, GL_FALSE, (const GLfloat*)I);
603
604 glUseProgram(0);
605}
PI_GLShaderProgram::Builder
Definition pi_shaders.h:64