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