GCC Code Coverage Report

Directory: ./
File: lib/geogram_gfx/GLUP/GLUP_context_ES.cpp
Date: 2026-09-07 02:37:58
Exec Total Coverage
Lines: 0 518 0.0%
Functions: 0 34 0.0%
Branches: 0 527 0.0%
Line Branch Exec Source
1 /*
2 * Copyright (c) 2000-2022 Inria
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * * Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 * * Neither the name of the ALICE Project-Team nor the names of its
14 * contributors may be used to endorse or promote products derived from this
15 * software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
21 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 * POSSIBILITY OF SUCH DAMAGE.
28 *
29 * Contact: Bruno Levy
30 *
31 * https://www.inria.fr/fr/bruno-levy
32 *
33 * Inria,
34 * Domaine de Voluceau,
35 * 78150 Le Chesnay - Rocquencourt
36 * FRANCE
37 *
38 */
39
40 #include <geogram_gfx/GLUP/GLUP_context_ES.h>
41 #include <geogram_gfx/basic/GLSL.h>
42 #include <geogram/basic/string.h>
43 #include <geogram/basic/command_line.h>
44
45 #ifdef GEO_OS_EMSCRIPTEN
46 #include <emscripten.h>
47 #endif
48
49 #ifdef GEO_GL_ES2
50
51 /*
52 * Notes:
53 * J'ai reussi a corriger le bug de picking de primitives WEBGL: ce sont les
54 * int-s encodes dans des float-s qui font un peu n'importe quoi. En ajoutant
55 * 0.5 au primitive_id a la sortie du vertex shader, ca regle le probleme.
56 *
57 * Il faudra peut-etre quand meme encoder les valeurs de picking de l'etat
58 * sous forme de vec4 plutot qu'en int, parceque je ne suis pas sur que ces
59 * ints puissent stocker plus que 65535 (mais le fait que je voie du bleu
60 * quand on met plein de primitive tend a montrer que ca marche quand meme...)
61 *
62 * Il manque encore le picking en mode "slice cell"
63 *
64 * Les triangles n'ont pas besoin d'indices d'elements je pense ...
65 *
66 * Slice cells:
67 * ============
68 * Pour implanter le mode "slice cells", je me demande s'il vaut mieux
69 * - avoir un tout petit buffer, et faire un flush par cellule ?
70 * - tout assembler dans des gros buffers, et faire un flush tous les
71 * 65K sommets ?
72 * -> essayer le premier (plus simple a programmer), et si \c{c}a rame
73 * faire le deuxi\`eme:
74 * Ca a l'air de marcher pas trop mal.
75 * Rem: le ELEMENT_ARRAY_BUFFER est en entiers 32 bits, certaines archis
76 * (telephones etc...) peuvent avoir besoin d'un ELEMENT_ARRAY_BUFFER
77 * 16 bits (ce qu'on pourrait assez facilement avoir...)
78 *
79 * texture 3D:
80 * ===========
81 * OpenGL ES 2.0 n'a pas de textures 3D, mais on peut les emuler avec des
82 * textures 2D:
83 * https://www.khronos.org/webgl/wiki/WebGL_and_OpenGL_Differences
84 * mais existe peut-etre une extension (a tester)
85 *
86 * The shaders
87 * ===========
88 * The shaders can be compiled either in OpenGL ES, GLSL 1.3 or GLSL 1.5.
89 * OpenGL ES mode is used by Emscripten.
90 * GLSL 1.3 mode is used by desktop OpenGL on:
91 * - Linux Intel i915
92 * - Linux NVidia
93 * - Windows
94 * GLSL 1.5 mode is used by destop OpenGL on MacOSX (MacOSX supports 1.5
95 * but does not support 1.3)
96 *
97 * TODO: In the shaders, in/out declarations are selected by #ifdef GL_ES,
98 * instead of testing GLSL version, is it normal ?
99 */
100
101 namespace {
102 using namespace GEO;
103
104 /**
105 * \brief Creates the source of a GLSL function that
106 * gets mesh texture coordinates.
107 * \details This function is necessary because we do not have
108 * a way of specifying uniform constant arrays in OpenGL ES 2.0
109 * \param[in] tex_coords an array of 4*\p nb_tex_coords floats
110 * \param[in] nb_tex_coords number of vec4s that define texture coordinates
111 * \return a std::string with the source of the shader
112 */
113 ✗ std::string create_mesh_tex_coord_lookup_function(
114 GLUPfloat* tex_coords, index_t nb_tex_coords
115 ) {
116 ✗ std::ostringstream output;
117 output <<
118 "vec4 get_mesh_tex_coord(in int vertex_id) { \n"
119 ✗ " int idx = glup_mod(vertex_id," << nb_tex_coords << ");\n";
120 ✗ for(index_t i=0; i<nb_tex_coords; ++i) {
121 ✗ output << " if(idx == " << i << ") {";
122 ✗ output << " return vec4("
123 ✗ << tex_coords[4*i ] << ","
124 ✗ << tex_coords[4*i+1] << ","
125 ✗ << tex_coords[4*i+2] << ","
126 ✗ << tex_coords[4*i+3] << "); }\n";
127 }
128 // Will never get here, but some GLSL compilers will not
129 // accept a function that may not return a value.
130 ✗ output << " return vec4(0.0, 0.0, 0.0, 0.0);\n";
131 ✗ output << "}\n";
132 ✗ return output.str();
133 ✗ }
134
135 /**
136 * \brief Creates the source of a GLSL function that
137 * gets mesh texture coordinates.
138 * \details The size of the texture coordinates array is
139 * automatically computed.
140 * \param[in] tex an array of texture coordinates
141 * \return a pointer to a string with the sources of
142 * the shader.
143 */
144
145 #define mesh_tex_coord_lookup(tex) \
146 create_mesh_tex_coord_lookup_function( \
147 tex, index_t(sizeof(tex) / (4*sizeof(float))) \
148 )
149 }
150
151 namespace GLUP {
152
153 extern bool vertex_array_emulate;
154
155 ✗ void Context_ES2::begin(GLUPprimitive primitive) {
156 ✗ if(primitive == GLUP_THICK_LINES) {
157 // Thick lines use the normal vertex attribute to store the second
158 // extremity of each segment.
159 ✗ immediate_state_.buffer[GLUP_NORMAL_ATTRIBUTE].enable();
160 }
161 ✗ Context::begin(primitive);
162 ✗ if(primitive == GLUP_THICK_LINES) {
163 // Thick lines need to replace line segments with quads.
164 // The additional vertices are generated in
165 // flush()_immediate_buffers (but we need twice the
166 // room in the buffer, so we flush when the buffer is half-full).
167 ✗ immediate_state_.begin(GLUP_THICK_LINES, IMMEDIATE_BUFFER_SIZE/2);
168 }
169 ✗ }
170
171 ✗ void Context_ES2::end() {
172 ✗ Context::end();
173 ✗ }
174
175 ✗ const char* Context_ES2::profile_name() const {
176 ✗ return "GLUPES2";
177 }
178
179 ✗ bool Context_ES2::primitive_supports_array_mode(GLUPprimitive prim) const {
180 // Note: points, spheres, lines with width 1
181 // and triangles without mesh can support array mode,
182 // but this will not work with picking, therefore it is disabled.
183 // In Android it is enabled. Additional test (triangles without mesh
184 // and line width 1) are done in MeshGfx.
185 ✗ if(does_not_need_picking_) {
186 return
187 ✗ (prim == GLUP_POINTS ||
188 ✗ prim == GLUP_SPHERES ||
189 ✗ prim == GLUP_LINES ||
190 ✗ prim == GLUP_TRIANGLES);
191 }
192 ✗ return false;
193 }
194
195 /**
196 * \brief Computes the number of elements in the buffer for
197 * a given primitive.
198 * \param[in] nb_vertices_per_glup_primitive number of vertices
199 * per primitive
200 * \param[in] nb_elements_per_glup_primitive number of elements
201 * per primitive
202 * \return total number of elements required to draw all the
203 * primitives in the buffer.
204 */
205 ✗ inline index_t nb_elements(
206 index_t nb_vertices_per_glup_primitive,
207 index_t nb_elements_per_glup_primitive
208 ) {
209 ✗ index_t nb_glup_primitives =
210 IMMEDIATE_BUFFER_SIZE / nb_vertices_per_glup_primitive;
211 return (
212 nb_glup_primitives * nb_elements_per_glup_primitive
213 ✗ );
214 }
215
216
217 ✗ void Context_ES2::setup() {
218
219 ✗ bool extension_standard_derivatives = false;
220 ✗ bool extension_vertex_array_object = false;
221
222 #ifdef GEO_OS_EMSCRIPTEN
223
224 /**
225 * \brief Tests whether a WebGL extension is supported.
226 * \details WebGL requires getExtension() to be called for initializing
227 * the extension (if supported, this returns an extension object,
228 * else this returns null).
229 * \param[in] ext the name of the extension surrounded by single quotes
230 * \retval true if the extension is supported
231 * \retval false otherwise
232 */
233 #define WEBGL_EXTENSION_SUPPORTED(ext) \
234 EM_ASM_INT({return ( \
235 Module.ctx.getExtension(ext) == null ? 0 : 1 \
236 );},0) != 0
237
238
239 extension_standard_derivatives = WEBGL_EXTENSION_SUPPORTED(
240 'OES_standard_derivatives'
241 );
242
243 extension_vertex_array_object = WEBGL_EXTENSION_SUPPORTED(
244 'OES_vertex_array_object'
245 );
246
247 #else
248 //TODO: it seems that standard derivatives and vertex array
249 //object extension names are not prefixed with GL_OES_ in
250 //OpenGL ES mode (but they are in WebGL, oh my....)
251
252 ✗ if(use_ES_profile_) {
253 extension_standard_derivatives =
254 ✗ extension_is_supported("GL_OES_standard_derivatives");
255
256 // ES profile can be artificially set to true for non-NVidia
257 // GPUs, see constructor.
258 ✗ extension_vertex_array_object =
259 ✗ extension_is_supported("GL_OES_vertex_array_object") ||
260 ✗ extension_is_supported("GL_ARB_vertex_array_object") ;
261
262 } else {
263 ✗ extension_standard_derivatives = true;
264 ✗ extension_vertex_array_object = true;
265 }
266 #endif
267
268 // Switch-on GLUP's emulation for Vertex Array
269 // Objects if they are not supported.
270 ✗ if(!extension_vertex_array_object) {
271 ✗ GLUP::vertex_array_emulate = true;
272 }
273
274 ✗ Logger::out("GLUP")
275 ✗ << "OES_standard_derivatives: "
276 ✗ << extension_standard_derivatives
277 ✗ << std::endl;
278
279 ✗ Logger::out("GLUP")
280 ✗ << "vertex_array_object: "
281 ✗ << extension_vertex_array_object
282 ✗ << std::endl;
283
284 ✗ create_CPU_side_uniform_buffer();
285
286
287 /************** VAOs and VBOs for whole cells clipping ******/
288
289 // Compute the maximum number of elements required to draw
290 // the vertices in a buffer, for all types of volumetric
291 // primitives.
292 ✗ index_t max_nb_elements = 0;
293 ✗ max_nb_elements = std::max(max_nb_elements, nb_elements(4,12));
294 ✗ max_nb_elements = std::max(max_nb_elements, nb_elements(8,36));
295 ✗ max_nb_elements = std::max(max_nb_elements, nb_elements(6,24));
296 ✗ max_nb_elements = std::max(max_nb_elements, nb_elements(5,18));
297 ✗ max_nb_elements = std::max(max_nb_elements, nb_elements(4,12));
298
299 ✗ nb_clip_cells_elements_ = max_nb_elements;
300 ✗ clip_cells_elements_ = new Numeric::uint16[nb_clip_cells_elements_];
301
302 ✗ glupGenVertexArrays(1,&clip_cells_VAO_);
303 ✗ glupBindVertexArray(clip_cells_VAO_);
304
305 ✗ bind_immediate_state_buffers_to_VAO();
306
307 ✗ glGenBuffers(1, &clip_cells_elements_VBO_);
308 ✗ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, clip_cells_elements_VBO_);
309
310 ✗ update_buffer_object(
311 ✗ clip_cells_elements_VBO_,
312 GL_ELEMENT_ARRAY_BUFFER,
313 ✗ max_nb_elements * sizeof(Numeric::uint32),
314 nullptr // no need to copy the buffer, it will be overwritten after.
315 );
316
317 ✗ glupBindVertexArray(0);
318
319 // Shaders in GLSL 2.0 do not support gl_VertexID, we need to
320 // emulate it.
321 ✗ create_vertex_id_VBO();
322
323 /************** VAOs and VBOs for sliced cells clipping ******/
324
325 ✗ max_nb_elements = 6;
326 ✗ index_t max_nb_vertices = 12;
327
328 ✗ glupGenVertexArrays(1,&sliced_cells_VAO_);
329 ✗ glupBindVertexArray(sliced_cells_VAO_);
330
331 ✗ glGenBuffers(1, &sliced_cells_elements_VBO_);
332 ✗ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sliced_cells_elements_VBO_);
333
334 ✗ update_buffer_object(
335 ✗ sliced_cells_elements_VBO_,
336 GL_ELEMENT_ARRAY_BUFFER,
337 ✗ max_nb_elements * sizeof(Numeric::uint16),
338 nullptr // no need to copy the buffer, it will be overwritten after.
339 );
340
341 ✗ for(index_t i=0; i<4; ++i) {
342 ✗ glGenBuffers(1, &sliced_cells_vertex_attrib_VBO_[i]);
343 ✗ glBindBuffer(GL_ARRAY_BUFFER, sliced_cells_vertex_attrib_VBO_[i]);
344
345 ✗ update_buffer_object(
346 ✗ sliced_cells_vertex_attrib_VBO_[i],
347 GL_ARRAY_BUFFER,
348 ✗ max_nb_vertices * sizeof(Numeric::float32) * 4,
349 nullptr // no need to copy the buffer, it will be overwritten.
350 );
351
352 ✗ glVertexAttribPointer(
353 i,
354 4,
355 GL_FLOAT,
356 GL_FALSE,
357 0,
358 nullptr
359 );
360 }
361 ✗ glEnableVertexAttribArray(0);
362 ✗ glupBindVertexArray(0);
363 ✗ }
364
365 ✗ Context_ES2::Context_ES2() :
366 ✗ nb_clip_cells_elements_(0),
367 ✗ clip_cells_elements_(nullptr),
368 ✗ clip_cells_elements_VBO_(0),
369 ✗ clip_cells_VAO_(0),
370 ✗ sliced_cells_elements_VBO_(0),
371 ✗ sliced_cells_VAO_(0),
372 ✗ vertex_id_VBO_bound_(false) {
373 ✗ for(index_t i=0; i<4; ++i) {
374 ✗ sliced_cells_vertex_attrib_VBO_[i] = 0;
375 }
376 ✗ GLSL_version_ = GLSL::supported_language_version();
377 #if defined(GEO_OS_EMSCRIPTEN) || defined(GEO_OS_ANDROID)
378 use_ES_profile_ = true;
379 Logger::out("GLUP") << "ES2 context, supported GLSL version = " << GLSL_version_
380 << std::endl;
381 #endif
382 // GLUP_THICK_LINES are rendered as quads, with four vertices. In this
383 // profile, we have no geometry shader and we need to do the job on our
384 // own in flush_immediate_buffers().
385 ✗ nb_vertices_per_primitive_[GLUP_THICK_LINES] = 4;
386
387 // If application does not need picking, then array mode is supported
388 // for points, lines, spheres, triangles.
389 // We force that for android (for now).
390 #ifdef GEO_OS_ANDROID
391 does_not_need_picking_ = true;
392 #else
393 ✗ does_not_need_picking_ = CmdLine::get_arg_bool(
394 ✗ "dbg:gfx:GLUPES2:does_not_need_picking"
395 );
396 #endif
397 ✗ }
398
399 ✗ Context_ES2::~Context_ES2() {
400 ✗ glDeleteBuffers(1,&clip_cells_elements_VBO_);
401 ✗ glupDeleteVertexArrays(1, &clip_cells_VAO_);
402 ✗ for(index_t i=0; i<4; ++i) {
403 ✗ glDeleteBuffers(1, &sliced_cells_vertex_attrib_VBO_[i]);
404 }
405 ✗ glupDeleteVertexArrays(1, &sliced_cells_VAO_);
406 ✗ delete[] clip_cells_elements_;
407 ✗ }
408
409 ✗ Memory::pointer Context_ES2::get_state_variable_address(
410 const char* name
411 ) {
412 ✗ geo_assert(
413 variable_to_offset_.find(name) != variable_to_offset_.end()
414 );
415 ✗ return uniform_buffer_data_ + variable_to_offset_[name];
416 }
417
418 ✗ void Context_ES2::do_update_uniform_buffer() {
419 ✗ GEO_CHECK_GL();
420
421 ✗ if(!uniform_buffer_dirty_) {
422 ✗ return;
423 }
424
425 ✗ GEO_CHECK_GL();
426
427 ✗ if(matrices_dirty_) {
428 ✗ update_matrices();
429 }
430
431 ✗ GEO_CHECK_GL();
432
433 ✗ if(lighting_dirty_) {
434 ✗ update_lighting();
435 }
436
437 ✗ GEO_CHECK_GL();
438
439 ✗ glUseProgram(latest_program_);
440
441 ✗ GEO_CHECK_GL();
442
443 ✗ if(latest_program_ != 0) {
444 ✗ copy_uniform_state_to_current_program();
445 }
446
447 ✗ GEO_CHECK_GL();
448
449 ✗ uniform_buffer_dirty_ = false;
450 }
451
452 ✗ void Context_ES2::copy_uniform_state_to_current_program() {
453 GLint loc;
454
455 // Matrices (in vertex shader).
456 {
457 ✗ loc = glGetUniformLocation(
458 latest_program_, "GLUP_VS.modelviewprojection_matrix"
459 );
460 ✗ glUniformMatrix4fv(
461 loc, 1, GL_FALSE,
462 ✗ uniform_state_.modelviewprojection_matrix.get_pointer()
463 );
464 ✗ loc = glGetUniformLocation(
465 latest_program_, "GLUP_VS.modelview_matrix"
466 );
467 ✗ glUniformMatrix4fv(
468 loc, 1, GL_FALSE,
469 ✗ uniform_state_.modelview_matrix.get_pointer()
470 );
471 ✗ loc = glGetUniformLocation(
472 latest_program_, "GLUP_VS.projection_matrix"
473 );
474 ✗ glUniformMatrix4fv(
475 loc, 1, GL_FALSE,
476 ✗ uniform_state_.projection_matrix.get_pointer()
477 );
478 ✗ loc = glGetUniformLocation(
479 latest_program_, "GLUP_VS.texture_matrix"
480 );
481 ✗ glUniformMatrix4fv(
482 loc, 1, GL_FALSE,
483 ✗ uniform_state_.texture_matrix.get_pointer()
484 );
485 ✗ loc = glGetUniformLocation(
486 latest_program_, "GLUP_VS.normal_matrix"
487 );
488
489 // Normal matrix is stored in state buffer with padding.
490 float normal_matrix[9];
491 ✗ for(index_t i=0; i<3; ++i) {
492 ✗ for(index_t j=0; j<3; ++j) {
493 ✗ normal_matrix[i*3+j] =
494 ✗ uniform_state_.normal_matrix.get_pointer()[i*4+j];
495 }
496 }
497
498 ✗ glUniformMatrix3fv(loc, 1, GL_FALSE, normal_matrix);
499
500
501 ✗ loc = glGetUniformLocation(
502 latest_program_, "GLUP_VS.inverse_modelview_matrix"
503 );
504 ✗ glUniformMatrix4fv(
505 loc, 1, GL_FALSE,
506 ✗ uniform_state_.inverse_modelview_matrix.get_pointer()
507 );
508 ✗ loc = glGetUniformLocation(
509 latest_program_, "GLUP_VS.inverse_projection_matrix"
510 );
511 ✗ glUniformMatrix4fv(
512 loc, 1, GL_FALSE,
513 ✗ uniform_state_.inverse_projection_matrix.get_pointer()
514 );
515 ✗ loc = glGetUniformLocation(
516 latest_program_, "GLUP_VS.inverse_modelviewprojection_matrix"
517 );
518 ✗ glUniformMatrix4fv(
519 loc, 1, GL_FALSE,
520 ✗ uniform_state_.inverse_modelviewprojection_matrix.get_pointer()
521 );
522
523 ✗ loc = glGetUniformLocation(
524 latest_program_, "GLUP_VS.viewport"
525 );
526 GLint viewport[4];
527 ✗ glGetIntegerv(GL_VIEWPORT, viewport);
528 ✗ glUniform4f(
529 loc,
530 ✗ float(viewport[0]),
531 ✗ float(viewport[1]),
532 ✗ float(viewport[2]),
533 ✗ float(viewport[3])
534 );
535 }
536
537 // Matrices (in fragment shader)
538 {
539 ✗ loc = glGetUniformLocation(
540 latest_program_, "GLUP.texture_matrix"
541 );
542 ✗ glUniformMatrix4fv(
543 loc, 1, GL_FALSE,
544 ✗ uniform_state_.texture_matrix.get_pointer()
545 );
546 ✗ loc = glGetUniformLocation(
547 latest_program_, "GLUP.modelviewprojection_matrix"
548 );
549 ✗ glUniformMatrix4fv(
550 loc, 1, GL_FALSE,
551 ✗ uniform_state_.modelviewprojection_matrix.get_pointer()
552 );
553 ✗ loc = glGetUniformLocation(
554 latest_program_, "GLUP.inverse_modelviewprojection_matrix"
555 );
556 ✗ glUniformMatrix4fv(
557 loc, 1, GL_FALSE,
558 ✗ uniform_state_.inverse_modelviewprojection_matrix.get_pointer()
559 );
560
561 ✗ loc = glGetUniformLocation(
562 latest_program_, "GLUP.normal_matrix"
563 );
564 // Normal matrix is stored in state buffer with padding.
565 float normal_matrix[9];
566 ✗ for(index_t i=0; i<3; ++i) {
567 ✗ for(index_t j=0; j<3; ++j) {
568 ✗ normal_matrix[i*3+j] =
569 ✗ uniform_state_.normal_matrix.get_pointer()[i*4+j];
570 }
571 }
572 ✗ glUniformMatrix3fv(loc, 1, GL_FALSE, normal_matrix);
573
574 ✗ loc = glGetUniformLocation(
575 latest_program_, "GLUP.viewport"
576 );
577 GLint viewport[4];
578 ✗ glGetIntegerv(GL_VIEWPORT, viewport);
579 ✗ glUniform4f(
580 loc,
581 ✗ float(viewport[0]),
582 ✗ float(viewport[1]),
583 ✗ float(viewport[2]),
584 ✗ float(viewport[3])
585 );
586 }
587
588 // Points (in vertex shader).
589 {
590 ✗ loc = glGetUniformLocation(
591 latest_program_, "GLUP_VS.point_size"
592 );
593 ✗ glUniform1f(loc, uniform_state_.point_size.get());
594 }
595
596
597 // Lighting.
598 {
599 ✗ loc = glGetUniformLocation(
600 latest_program_, "GLUP.light_vector"
601 );
602 ✗ glUniform3fv(
603 ✗ loc, 1, uniform_state_.light_vector.get_pointer()
604 );
605 ✗ loc = glGetUniformLocation(
606 latest_program_, "GLUP.light_half_vector"
607 );
608 ✗ glUniform3fv(
609 ✗ loc, 1, uniform_state_.light_half_vector.get_pointer()
610 );
611 }
612
613 // All the toggles.
614 ✗ for(index_t i=0; i<uniform_state_.toggle.size(); ++i) {
615 ✗ loc = glGetUniformLocation(
616 latest_program_,
617 ✗ ("GLUP." + uniform_state_.toggle[i].name()).c_str()
618 );
619 ✗ glUniform1i(
620 ✗ loc, GLint(uniform_state_.toggle[i].get())
621 );
622 }
623
624 // Colors.
625 ✗ if(!uniform_state_.toggle[GLUP_VERTEX_COLORS].get()) {
626 ✗ for(index_t i=0; i<uniform_state_.color.size(); ++i) {
627 ✗ loc = glGetUniformLocation(
628 latest_program_,
629 ✗ ("GLUP." + uniform_state_.color[i].name()).c_str()
630 );
631 ✗ glUniform4fv(
632 ✗ loc, 1, uniform_state_.color[i].get_pointer()
633 );
634 }
635 }
636
637 // Mesh.
638 ✗ if(uniform_state_.toggle[GLUP_DRAW_MESH].get()) {
639 ✗ loc = glGetUniformLocation(latest_program_, "GLUP.mesh_width");
640 ✗ glUniform1f(loc, uniform_state_.mesh_width.get());
641 }
642
643 ✗ loc = glGetUniformLocation(latest_program_, "GLUP_VS.mesh_width");
644 ✗ glUniform1f(loc, uniform_state_.mesh_width.get());
645
646 // Texturing.
647 ✗ if(uniform_state_.toggle[GLUP_TEXTURING].get()) {
648 ✗ loc = glGetUniformLocation(
649 latest_program_, "GLUP.texture_mode"
650 );
651 ✗ glUniform1i(loc, uniform_state_.texture_mode.get());
652 ✗ loc = glGetUniformLocation(
653 latest_program_, "GLUP.texture_type"
654 );
655 ✗ glUniform1i(loc, uniform_state_.texture_type.get());
656 }
657
658 // Cell shrink
659 ✗ loc = glGetUniformLocation(latest_program_, "GLUP.cells_shrink");
660 ✗ glUniform1f(loc, uniform_state_.cells_shrink.get());
661
662 // Picking
663 ✗ if(uniform_state_.toggle[GLUP_PICKING].get()) {
664 ✗ loc = glGetUniformLocation(
665 latest_program_, "GLUP.picking_mode"
666 );
667 ✗ glUniform1i(loc, uniform_state_.picking_mode.get());
668 ✗ loc = glGetUniformLocation(
669 latest_program_, "GLUP.picking_id"
670 );
671 ✗ glUniform1i(loc, uniform_state_.picking_id.get());
672 ✗ loc = glGetUniformLocation(
673 latest_program_, "GLUP.base_picking_id"
674 );
675 ✗ glUniform1i(loc, uniform_state_.base_picking_id.get());
676 }
677
678 // Clipping.
679 ✗ if(uniform_state_.toggle[GLUP_CLIPPING].get()) {
680 ✗ loc = glGetUniformLocation(
681 latest_program_, "GLUP.clipping_mode"
682 );
683 ✗ glUniform1i(loc, uniform_state_.clipping_mode.get());
684 ✗ loc = glGetUniformLocation(
685 latest_program_, "GLUP.clip_plane"
686 );
687 ✗ glUniform4fv(loc, 1, uniform_state_.clip_plane.get_pointer());
688 ✗ loc = glGetUniformLocation(
689 latest_program_, "GLUP_VS.world_clip_plane"
690 );
691 ✗ glUniform4fv(
692 ✗ loc, 1, uniform_state_.world_clip_plane.get_pointer()
693 );
694 ✗ loc = glGetUniformLocation(
695 latest_program_, "GLUP.world_clip_plane"
696 );
697 ✗ glUniform4fv(
698 ✗ loc, 1, uniform_state_.world_clip_plane.get_pointer()
699 );
700 }
701
702 // alpha discard.
703 ✗ if(uniform_state_.toggle[GLUP_ALPHA_DISCARD].get()) {
704 ✗ loc = glGetUniformLocation(
705 latest_program_, "GLUP.alpha_threshold"
706 );
707 ✗ glUniform1f(loc, uniform_state_.alpha_threshold.get());
708 }
709
710 // specular
711 {
712 ✗ loc = glGetUniformLocation(
713 latest_program_, "GLUP.specular"
714 );
715 ✗ glUniform1f(loc, uniform_state_.specular.get());
716 }
717 ✗ }
718
719 ✗ void Context_ES2::update_base_picking_id(GLint new_value) {
720 ✗ if(uniform_state_.toggle[GLUP_PICKING].get()) {
721 ✗ uniform_state_.base_picking_id.set(new_value);
722 ✗ if(latest_program_ != 0) {
723 ✗ GEO_CHECK_GL();
724 ✗ GLint loc = glGetUniformLocation(
725 latest_program_, "GLUP.base_picking_id"
726 );
727 ✗ GEO_CHECK_GL();
728 ✗ glUseProgram(latest_program_);
729 ✗ glUniform1i(loc, new_value);
730 ✗ GEO_CHECK_GL();
731 }
732 }
733 ✗ }
734
735
736 /*****************************************************************************/
737
738 ✗ void Context_ES2::setup_GLUP_POINTS() {
739 ✗ set_primitive_info(
740 GLUP_POINTS, GL_POINTS,
741 GLSL::compile_program_with_includes_no_link(
742 this,
743 "//stage GL_VERTEX_SHADER\n"
744 "//import <GLUPES/points_vertex_shader.h>\n",
745 "//stage GL_FRAGMENT_SHADER\n"
746 "//import <GLUPES/spheres_fragment_shader.h>\n"
747 )
748 );
749 ✗ }
750
751 ✗ void Context_ES2::setup_GLUP_LINES() {
752 ✗ set_primitive_info(
753 GLUP_LINES, GL_LINES,
754 GLSL::compile_program_with_includes_no_link(
755 this,
756 "//stage GL_VERTEX_SHADER\n"
757 "//import <GLUPES/vertex_shader.h>\n",
758 "//stage GL_FRAGMENT_SHADER\n"
759 "//import <GLUPES/lines_fragment_shader.h>\n"
760 )
761 );
762 ✗ }
763
764 ✗ void Context_ES2::setup_GLUP_THICK_LINES() {
765 // GLUP_THICK_LINES are rendered as quads,
766 // Only immediate mode is supported.
767 // the line segments given by the user are transformed into quads
768 // in flush_immediate_buffers().
769
770 // For each quad, we draw two triangles
771 static index_t element_indices[6] = {
772 0, 1, 2,
773 2, 1, 3
774 };
775
776 ✗ set_primitive_info_immediate_index_mode(
777 primitive_source_, GL_TRIANGLES,
778 GLSL::compile_program_with_includes_no_link(
779 this,
780 "//stage GL_VERTEX_SHADER\n"
781 "//import <GLUPES/thick_lines_vertex_shader.h>\n",
782 "//stage GL_FRAGMENT_SHADER\n"
783 "//import <GLUPES/thick_lines_fragment_shader.h>\n"
784 ),
785 index_t(sizeof(element_indices)/sizeof(index_t)),
786 element_indices
787 );
788
789 // The number of vertices per thick line segment is adapted in two
790 // other places in the code:
791 // - in Context_ES2::begin(), the maximum index for the immediate
792 // buffers is set to half-buffer (so that we have enough room to
793 // generate the additional vertices to render quads).
794 // - in Context_ES2::flush_immediate_buffers(), the immediate buffers
795 // are reshuffled, in order to create quads, with
796 // their four vertices set to the first vertex of each segment,
797 // and "normals" set the second vertex of each segment.
798 //
799 // The vertex shader uses the primitive Id to know which vertex
800 // goes where.
801 //
802 // Note: since the GLUP_NORMAL_ATTRIBUTE is used to store the second
803 // vertex of each segment, it needs to be bound. It is done in
804 // Context_ES2::begin() (that calls then Context::begin()).
805 ✗ }
806
807 ✗ void Context_ES2::setup_primitive_generic(
808 index_t nb_elements_per_primitive,
809 index_t* element_indices
810 ) {
811
812 ✗ set_primitive_info_immediate_index_mode(
813 primitive_source_, GL_TRIANGLES,
814 GLSL::compile_program_with_includes_no_link(
815 this,
816 "//stage GL_VERTEX_SHADER\n"
817 "//import <GLUPES/vertex_shader.h>\n",
818 "//stage GL_FRAGMENT_SHADER\n"
819 "//import <GLUPES/fragment_shader.h>\n"
820 ),
821 nb_elements_per_primitive, element_indices
822 );
823 ✗ }
824
825 ✗ void Context_ES2::setup_GLUP_TRIANGLES() {
826 static index_t element_indices[3] = {
827 0, 1, 2
828 };
829 ✗ setup_primitive_generic(
830 index_t(sizeof(element_indices)/sizeof(index_t)),
831 element_indices
832 );
833 ✗ }
834
835 ✗ void Context_ES2::setup_GLUP_QUADS() {
836 static index_t element_indices[6] = {
837 0, 1, 2,
838 0, 2, 3
839 };
840 ✗ setup_primitive_generic(
841 index_t(sizeof(element_indices)/sizeof(index_t)),
842 element_indices
843 );
844 ✗ }
845
846 ✗ void Context_ES2::setup_GLUP_TETRAHEDRA() {
847 static index_t element_indices[12] = {
848 1,3,2,
849 0,2,3,
850 3,1,0,
851 0,1,2
852 };
853 ✗ setup_primitive_generic(
854 index_t(sizeof(element_indices)/sizeof(index_t)),
855 element_indices
856 );
857 ✗ }
858
859 ✗ void Context_ES2::setup_GLUP_HEXAHEDRA() {
860 static index_t element_indices[36] = {
861 0,2,6, 0,6,4,
862 3,1,5, 3,5,7,
863 1,0,4, 1,4,5,
864 2,3,7, 2,7,6,
865 1,3,2, 1,2,0,
866 4,6,7, 4,7,5
867 };
868 ✗ setup_primitive_generic(
869 index_t(sizeof(element_indices)/sizeof(index_t)),
870 element_indices
871 );
872 ✗ }
873
874 ✗ void Context_ES2::setup_GLUP_PRISMS() {
875 static index_t element_indices[24] = {
876 0,1,2,
877 3,5,4,
878 0,3,4, 0,4,1,
879 0,2,5, 0,5,3,
880 1,4,5, 1,5,2
881 };
882 ✗ setup_primitive_generic(
883 index_t(sizeof(element_indices)/sizeof(index_t)),
884 element_indices
885 );
886 ✗ }
887
888 ✗ void Context_ES2::setup_GLUP_PYRAMIDS() {
889 static index_t element_indices[18] = {
890 0,1,2, 0,2,3,
891 0,4,1,
892 0,3,4,
893 2,4,3,
894 2,1,4
895 };
896 ✗ setup_primitive_generic(
897 index_t(sizeof(element_indices)/sizeof(index_t)),
898 element_indices
899 );
900 ✗ }
901
902 ✗ void Context_ES2::setup_GLUP_CONNECTORS() {
903 static index_t element_indices[12] = {
904 0,1,2, 0,2,3,
905 2,1,0,
906 3,2,0
907 };
908 ✗ setup_primitive_generic(
909 index_t(sizeof(element_indices)/sizeof(index_t)),
910 element_indices
911 );
912 ✗ }
913
914 ✗ void Context_ES2::setup_GLUP_SPHERES() {
915 ✗ set_primitive_info(
916 GLUP_SPHERES, GL_POINTS,
917 GLSL::compile_program_with_includes_no_link(
918 this,
919 "//stage GL_VERTEX_SHADER\n"
920 "//import <GLUPES/spheres_vertex_shader.h>\n",
921 "//stage GL_FRAGMENT_SHADER\n"
922 "//import <GLUPES/spheres_fragment_shader.h>\n"
923 )
924 );
925 ✗ }
926
927 ✗ bool Context_ES2::cell_by_cell_clipping() const {
928 ✗ if(!uniform_state_.toggle[GLUP_CLIPPING].get()) {
929 ✗ return false;
930 }
931
932 ✗ if(
933 ✗ immediate_state_.primitive() != GLUP_TETRAHEDRA &&
934 ✗ immediate_state_.primitive() != GLUP_HEXAHEDRA &&
935 ✗ immediate_state_.primitive() != GLUP_PRISMS &&
936 ✗ immediate_state_.primitive() != GLUP_PYRAMIDS &&
937 ✗ immediate_state_.primitive() != GLUP_CONNECTORS
938 ) {
939 ✗ return false;
940 }
941
942 return (
943 ✗ uniform_state_.clipping_mode.get() == GLUP_CLIP_WHOLE_CELLS ||
944 ✗ uniform_state_.clipping_mode.get() == GLUP_CLIP_STRADDLING_CELLS
945 ✗ );
946 }
947
948 ✗ bool Context_ES2::sliced_cells_clipping() const {
949 ✗ if(!uniform_state_.toggle[GLUP_CLIPPING].get()) {
950 ✗ return false;
951 }
952
953 ✗ if(
954 ✗ immediate_state_.primitive() != GLUP_TETRAHEDRA &&
955 ✗ immediate_state_.primitive() != GLUP_HEXAHEDRA &&
956 ✗ immediate_state_.primitive() != GLUP_PRISMS &&
957 ✗ immediate_state_.primitive() != GLUP_PYRAMIDS &&
958 ✗ immediate_state_.primitive() != GLUP_CONNECTORS
959 ) {
960 ✗ return false;
961 }
962
963 return (
964 ✗ uniform_state_.clipping_mode.get() == GLUP_CLIP_SLICE_CELLS
965 ✗ );
966 }
967
968 ✗ void Context_ES2::flush_immediate_buffers_with_cell_by_cell_clipping() {
969 ✗ index_t cur_vertex = 0;
970 ✗ index_t cur_element_out = 0;
971 index_t nb_vertices_per_cell =
972 ✗ nb_vertices_per_primitive_[immediate_state_.primitive()];
973 index_t nb_elements_per_cell = primitive_info_[
974 ✗ immediate_state_.primitive()].nb_elements_per_primitive;
975
976 // Assemble the list of indices (elements) that correspond
977 // to the vertices of the visible cells.
978 ✗ while(cur_vertex < immediate_state_.nb_vertices()) {
979 ✗ if(!cell_is_clipped(cur_vertex)) {
980 ✗ for(index_t lei=0; lei < nb_elements_per_cell; ++lei) {
981 ✗ geo_debug_assert(
982 cur_element_out < nb_clip_cells_elements_
983 );
984 ✗ clip_cells_elements_[cur_element_out] =
985 Numeric::uint16(
986 ✗ cur_vertex + primitive_info_[
987 ✗ immediate_state_.primitive()
988 ✗ ].primitive_elements[lei]
989 );
990 ✗ ++cur_element_out;
991 }
992 }
993 ✗ cur_vertex += nb_vertices_per_cell;
994 }
995
996 ✗ glupBindVertexArray(clip_cells_VAO_);
997
998 // Stream the values in all bound buffers (and attach
999 // them to the VAO).
1000 ✗ for(index_t i=0; i<ImmediateState::NB_IMMEDIATE_BUFFERS; ++i) {
1001 ✗ if(immediate_state_.buffer[i].is_enabled()) {
1002 ✗ glEnableVertexAttribArray(i);
1003 ✗ if(immediate_state_.buffer[i].VBO() != 0) {
1004 ✗ stream_buffer_object(
1005 immediate_state_.buffer[i].VBO(),
1006 GL_ARRAY_BUFFER,
1007 immediate_state_.buffer[i].size_in_bytes(),
1008 ✗ immediate_state_.buffer[i].data()
1009 );
1010 }
1011 }
1012 }
1013
1014 ✗ if(
1015 ✗ vertex_id_VBO_ != 0 && ((
1016 ✗ immediate_state_.primitive() >= GLUP_TRIANGLES &&
1017 ✗ uniform_state_.toggle[GLUP_DRAW_MESH].get()
1018 ✗ ) || uniform_state_.toggle[GLUP_PICKING].get())
1019 ) {
1020 ✗ if(!vertex_id_VBO_bound_) {
1021 ✗ glEnableVertexAttribArray(GLUP_VERTEX_ID_ATTRIBUTE);
1022 ✗ glBindBuffer(
1023 GL_ARRAY_BUFFER, vertex_id_VBO_
1024 );
1025 ✗ glVertexAttribPointer(
1026 GLUP_VERTEX_ID_ATTRIBUTE,
1027 1, // 1 component per attribute
1028 GL_UNSIGNED_SHORT, // components are 16 bits integers
1029 GL_FALSE, // do not normalize
1030 0, // stride
1031 nullptr // pointer (relative to bound VBO beginning)
1032 );
1033 ✗ vertex_id_VBO_bound_ = true;
1034 }
1035 } else {
1036 ✗ if(vertex_id_VBO_bound_) {
1037 ✗ vertex_id_VBO_bound_ = false;
1038 ✗ glDisableVertexAttribArray(GLUP_VERTEX_ID_ATTRIBUTE);
1039 }
1040 }
1041
1042 // Stream the indices into the elements VBO.
1043 ✗ stream_buffer_object(
1044 ✗ clip_cells_elements_VBO_,
1045 GL_ELEMENT_ARRAY_BUFFER,
1046 ✗ cur_element_out * sizeof(Numeric::uint16),
1047 ✗ clip_cells_elements_
1048 );
1049
1050 ✗ glDrawElements(
1051 ✗ primitive_info_[immediate_state_.primitive()].GL_primitive,
1052 GLsizei(cur_element_out),
1053 GL_UNSIGNED_SHORT,
1054 nullptr
1055 );
1056
1057 ✗ glupBindVertexArray(0);
1058 ✗ glDisableVertexAttribArray(GLUP_VERTEX_ID_ATTRIBUTE);
1059 ✗ immediate_state_.reset();
1060 ✗ }
1061
1062 ✗ void Context_ES2::flush_immediate_buffers_with_sliced_cells_clipping() {
1063
1064 ✗ MarchingCell* marching_cell = nullptr;
1065 ✗ switch(immediate_state_.primitive()) {
1066 ✗ case GLUP_TETRAHEDRA:
1067 ✗ marching_cell = &marching_tet_;
1068 ✗ break;
1069 ✗ case GLUP_HEXAHEDRA:
1070 ✗ marching_cell = &marching_hex_;
1071 ✗ break;
1072 ✗ case GLUP_PRISMS:
1073 ✗ marching_cell = &marching_prism_;
1074 ✗ break;
1075 ✗ case GLUP_PYRAMIDS:
1076 ✗ marching_cell = &marching_pyramid_;
1077 ✗ break;
1078 ✗ case GLUP_CONNECTORS:
1079 ✗ marching_cell = &marching_connector_;
1080 ✗ break;
1081 ✗ case GLUP_POINTS:
1082 case GLUP_LINES:
1083 case GLUP_THICK_LINES:
1084 case GLUP_TRIANGLES:
1085 case GLUP_QUADS:
1086 case GLUP_SPHERES:
1087 case GLUP_NB_PRIMITIVES:
1088 ✗ geo_assert_not_reached;
1089 }
1090
1091 ✗ glupBindVertexArray(sliced_cells_VAO_);
1092
1093 ✗ index_t v0=0;
1094 ✗ while(v0 < immediate_state_.nb_vertices()) {
1095 ✗ index_t config = get_config(v0, marching_cell->nb_vertices());
1096
1097 // Compute all the intersection vertices (plus their
1098 // attributes if enabled).
1099 ✗ for(index_t i=0; i<marching_cell->config_size(config); ++i) {
1100 ✗ index_t e = marching_cell->config_edges(config)[i];
1101 ✗ compute_intersection(
1102 ✗ v0+marching_cell->edge_vertex(e,0),
1103 ✗ v0+marching_cell->edge_vertex(e,1),
1104 e
1105 );
1106 }
1107
1108 ✗ if(marching_cell->config_size(config) != 0) {
1109
1110 ✗ stream_buffer_object(
1111 ✗ sliced_cells_elements_VBO_,
1112 GL_ELEMENT_ARRAY_BUFFER,
1113 ✗ marching_cell->max_config_size() * sizeof(Numeric::uint32),
1114 ✗ marching_cell->config_edges(config)
1115 );
1116
1117 ✗ stream_buffer_object(
1118 ✗ sliced_cells_vertex_attrib_VBO_[0],
1119 GL_ARRAY_BUFFER,
1120 12 * sizeof(Numeric::float32) * 4,
1121 ✗ &isect_vertex_attribute_[0][0]
1122 );
1123
1124 ✗ for(index_t i=1; i<4; ++i) {
1125 ✗ if(immediate_state_.buffer[i].is_enabled()) {
1126 ✗ glEnableVertexAttribArray(i);
1127 ✗ stream_buffer_object(
1128 ✗ sliced_cells_vertex_attrib_VBO_[i],
1129 GL_ARRAY_BUFFER,
1130 12 * sizeof(Numeric::float32) * 4,
1131 ✗ &isect_vertex_attribute_[i][0]
1132 );
1133 } else {
1134 ✗ glDisableVertexAttribArray(i);
1135 }
1136 }
1137
1138 ✗ glDrawElements(
1139 GL_TRIANGLE_FAN,
1140 ✗ GLsizei(marching_cell->config_size(config)),
1141 GL_UNSIGNED_INT,
1142 nullptr
1143 );
1144 }
1145
1146 ✗ v0 += marching_cell->nb_vertices();
1147 }
1148
1149 ✗ glupBindVertexArray(0);
1150 ✗ immediate_state_.reset();
1151 ✗ }
1152
1153 ✗ void Context_ES2::flush_immediate_buffers() {
1154 ✗ if(immediate_state_.primitive() == GLUP_THICK_LINES) {
1155 // Make sure we have enough room to double the number of
1156 // vertices in immediate buffers
1157 ✗ geo_assert(
1158 immediate_state_.nb_vertices() <= IMMEDIATE_BUFFER_SIZE/2
1159 );
1160
1161 // input:
1162 // (v1 v2), (v1 v2), (v1 v2) in vertex buffer
1163 //
1164 // output:
1165 // (v1 v1 v1 v1) (v1 v1 v1 v1) in vertex buffer
1166 // (v2 v2 v2 v2) (v2 v2 v2 v2) in normal buffer
1167 //
1168 // Each line segment becomes four identical vertices. Vertex
1169 // shader distinguished them based on (vertex_id % 4).
1170
1171 ✗ for(index_t v=0; v<immediate_state_.nb_vertices(); ++v) {
1172 ✗ index_t from = immediate_state_.nb_vertices()-v-1;
1173 ✗ index_t to = 2*from;
1174 ✗ immediate_state_.copy_element(to,from);
1175 }
1176
1177 ✗ for(index_t v=0; v<immediate_state_.nb_vertices(); ++v) {
1178 ✗ index_t from = 2*v;
1179 ✗ index_t to = 2*v+1;
1180 ✗ immediate_state_.copy_element(to,from);
1181 }
1182
1183 // This doubles immediate_state_.nb_vertices()
1184 // (and does nothing else)
1185 ✗ immediate_state_.reset(immediate_state_.nb_vertices()*2);
1186
1187 ✗ for(index_t v1=0; v1<immediate_state_.nb_vertices(); v1+=4) {
1188 ✗ index_t v2=v1+1;
1189 ✗ index_t v3=v1+2;
1190 ✗ index_t v4=v1+3;
1191
1192 // copy second extremity to normal attribute
1193 // of the four vertices
1194 ✗ immediate_state_.buffer[GLUP_NORMAL_ATTRIBUTE].copy(
1195 v1,
1196 ✗ immediate_state_.buffer[GLUP_VERTEX_ATTRIBUTE],
1197 v3
1198 );
1199 ✗ immediate_state_.buffer[GLUP_NORMAL_ATTRIBUTE].copy(
1200 v2,
1201 ✗ immediate_state_.buffer[GLUP_VERTEX_ATTRIBUTE],
1202 v3
1203 );
1204 ✗ immediate_state_.buffer[GLUP_NORMAL_ATTRIBUTE].copy(
1205 v3,
1206 ✗ immediate_state_.buffer[GLUP_VERTEX_ATTRIBUTE],
1207 v3
1208 );
1209 ✗ immediate_state_.buffer[GLUP_NORMAL_ATTRIBUTE].copy(
1210 v4,
1211 ✗ immediate_state_.buffer[GLUP_VERTEX_ATTRIBUTE],
1212 v3
1213 );
1214
1215 // copy first extremity to vertex attribute of the four vertices
1216 // (three in fact, first one is already there)
1217 ✗ immediate_state_.buffer[GLUP_VERTEX_ATTRIBUTE].copy(v2,v1);
1218 ✗ immediate_state_.buffer[GLUP_VERTEX_ATTRIBUTE].copy(v3,v1);
1219 ✗ immediate_state_.buffer[GLUP_VERTEX_ATTRIBUTE].copy(v4,v1);
1220 }
1221 }
1222 ✗ classify_vertices_in_immediate_buffers();
1223 ✗ shrink_cells_in_immediate_buffers();
1224 ✗ if(cell_by_cell_clipping()) {
1225 ✗ flush_immediate_buffers_with_cell_by_cell_clipping();
1226 ✗ } else if(sliced_cells_clipping()) {
1227 ✗ flush_immediate_buffers_with_sliced_cells_clipping();
1228 } else {
1229 ✗ Context::flush_immediate_buffers();
1230 }
1231 ✗ }
1232
1233
1234 ✗ void Context_ES2::get_primitive_pseudo_file(
1235 std::vector<GLSL::Source>& sources
1236 ) {
1237 ✗ Context::get_primitive_pseudo_file(sources);
1238
1239 static GLUPfloat tri_tex_coords[12] = {
1240 1.0f, 0.0f, 0.0f, 0.0f,
1241 0.0f, 1.0f, 0.0f, 0.0f,
1242 0.0f, 0.0f, 1.0f, 0.0f
1243 };
1244
1245 static GLUPfloat quad_tex_coords[16] = {
1246 0.0f, 0.0f, 1.0f, 1.0f,
1247 1.0f, 0.0f, 0.0f, 1.0f,
1248 1.0f, 1.0f, 0.0f, 0.0f,
1249 0.0f, 1.0f, 1.0f, 0.0f,
1250 };
1251
1252 static GLUPfloat tet_tex_coords[16] = {
1253 1.0f, 0.0f, 0.0f, 0.0f,
1254 0.0f, 1.0f, 0.0f, 0.0f,
1255 0.0f, 0.0f, 1.0f, 0.0f,
1256 0.0f, 0.0f, 0.0f, 1.0f
1257 };
1258
1259 static GLUPfloat hex_tex_coords[32] = {
1260 0.0f, 0.0f, 0.0f, 0.0f,
1261 0.0f, 0.0f, 1.0f, 0.0f,
1262 0.0f, 1.0f, 0.0f, 0.0f,
1263 0.0f, 1.0f, 1.0f, 0.0f,
1264 1.0f, 0.0f, 0.0f, 0.0f,
1265 1.0f, 0.0f, 1.0f, 0.0f,
1266 1.0f, 1.0f, 0.0f, 0.0f,
1267 1.0f, 1.0f, 1.0f, 0.0f,
1268 };
1269
1270 static GLUPfloat prism_tex_coords[24] = {
1271 1.0f, 0.0f, 0.0f, 0.0f,
1272 0.0f, 1.0f, 0.0f, 0.0f,
1273 0.0f, 0.0f, 1.0f, 0.0f,
1274 1.0f, 0.0f, 0.0f, 1.0f,
1275 0.0f, 1.0f, 0.0f, 1.0f,
1276 0.0f, 0.0f, 1.0f, 1.0f
1277 };
1278
1279
1280 ✗ switch(primitive_source_) {
1281 ✗ case GLUP_TRIANGLES:
1282 ✗ sources.push_back(mesh_tex_coord_lookup(tri_tex_coords));
1283 ✗ break;
1284 ✗ case GLUP_QUADS:
1285 ✗ sources.push_back(mesh_tex_coord_lookup(quad_tex_coords));
1286 ✗ break;
1287 ✗ case GLUP_TETRAHEDRA:
1288 ✗ sources.push_back(mesh_tex_coord_lookup(tet_tex_coords));
1289 ✗ break;
1290 ✗ case GLUP_HEXAHEDRA:
1291 ✗ sources.push_back(mesh_tex_coord_lookup(hex_tex_coords));
1292 ✗ break;
1293 ✗ case GLUP_PRISMS:
1294 ✗ sources.push_back(mesh_tex_coord_lookup(prism_tex_coords));
1295 ✗ break;
1296
1297 ✗ case GLUP_POINTS:
1298 case GLUP_LINES:
1299 case GLUP_THICK_LINES:
1300 case GLUP_PYRAMIDS:
1301 case GLUP_CONNECTORS:
1302 case GLUP_SPHERES:
1303 ✗ sources.push_back(
1304 ✗ "#define GLUP_NO_MESH_TEX_COORDS\n"
1305 "vec4 get_mesh_tex_coord(in int vertex_id) {\n"
1306 " return vec4(0.0, 0.0, 0.0, 0.0);\n"
1307 "}\n"
1308 );
1309 ✗ break;
1310
1311 ✗ case GLUP_NB_PRIMITIVES:
1312 ✗ geo_assert_not_reached;
1313 }
1314 ✗ }
1315
1316 ✗ void Context_ES2::get_vertex_shader_preamble_pseudo_file(
1317 std::vector<GLSL::Source>& sources
1318 ) {
1319 ✗ if(use_ES_profile_) {
1320 ✗ if(GLSL_version_ >= 3.0) {
1321 ✗ sources.push_back(
1322 ✗ "#version 300 es\n"
1323 "#define GLUP_VERTEX_SHADER \n"
1324 );
1325 } else {
1326 ✗ sources.push_back(
1327 ✗ "#version 100\n"
1328 "#define GLUP_VERTEX_SHADER \n"
1329 );
1330 }
1331 } else {
1332 ✗ sources.push_back(
1333 #ifdef GEO_OS_APPLE
1334 "#version 150 core \n"
1335 #else
1336 ✗ "#version 130 \n"
1337 #endif
1338 "#define GLUP_VERTEX_SHADER \n"
1339 );
1340 }
1341 ✗ }
1342
1343
1344 ✗ void Context_ES2::get_fragment_shader_preamble_pseudo_file(
1345 std::vector<GLSL::Source>& sources
1346 ) {
1347 ✗ if(use_ES_profile_) {
1348 #if defined(GEO_OS_EMSCRIPTEN) || defined(GEO_OS_ANDROID)
1349 if(GLSL_version_ >= 3.0) {
1350 sources.push_back("#version 300 es\n");
1351 } else {
1352 sources.push_back("#version 100\n");
1353 }
1354 #endif
1355 ✗ sources.push_back(
1356 ✗ "#define GLUP_FRAGMENT_SHADER \n"
1357 "#extension GL_OES_standard_derivatives : enable \n"
1358 "#extension GL_EXT_frag_depth : enable \n"
1359 "#extension GL_OES_texture3D : enable \n"
1360 "#ifndef GL_OES_texture3D \n"
1361 " #define GLUP_NO_TEXTURE_3D \n"
1362 "#endif \n"
1363 "precision highp float; \n"
1364 "#ifdef GL_FRAGMENT_PRECISION_HIGH \n"
1365 " precision highp int; \n"
1366 "#endif \n"
1367 );
1368 } else {
1369 ✗ sources.push_back(
1370 #ifdef GEO_OS_APPLE
1371 "#version 150 core \n"
1372 #else
1373 ✗ "#version 130 \n"
1374 #endif
1375 "#define GLUP_FRAGMENT_SHADER \n"
1376 );
1377 }
1378 ✗ }
1379
1380 ✗ void Context_ES2::get_toggles_pseudo_file(
1381 std::vector<GLSL::Source>& sources
1382 ) {
1383
1384 // In GLUPES2, the state is split into vertex shader
1385 // and fragment shader state. The toggles are in the fragment
1386 // shader state, therefore the vertex shader can only know the
1387 // statically defined toggles. For the other ones, we
1388 // "conservatively" assume that they are on (on the worst case,
1389 // this means the vertex shader will copy more attributes than
1390 // needed).
1391
1392 std::string toggle_maybe_enabled_source =
1393 ✗ "bool glupIsEnabled(in int toggle) {\n";
1394
1395 ✗ for(index_t i=0; i<uniform_state_.toggle.size(); ++i) {
1396 ✗ std::string toggle_var_name = uniform_state_.toggle[i].name();
1397 ✗ std::string toggle_name = toggle_var_name;
1398 ✗ size_t pos = toggle_name.find("_enabled");
1399 ✗ geo_assert(pos != std::string::npos);
1400 ✗ toggle_name = "GLUP_" +
1401 ✗ String::to_uppercase(toggle_name.substr(0,pos));
1402
1403 std::string test =
1404 ✗ " if(toggle=="+toggle_name + ") {\n";
1405
1406 ✗ toggle_maybe_enabled_source += test;
1407
1408 ✗ if(toggles_source_undetermined_ & (1 << i)) {
1409 ✗ toggle_maybe_enabled_source += " return true;\n";
1410 } else {
1411 ✗ if(toggles_source_state_ & (1 << i)) {
1412 toggle_maybe_enabled_source +=
1413 ✗ " return true;\n";
1414 } else {
1415 toggle_maybe_enabled_source +=
1416 ✗ " return false;\n";
1417 }
1418 }
1419 ✗ toggle_maybe_enabled_source += " }\n";
1420 ✗ }
1421
1422 ✗ toggle_maybe_enabled_source += " return false; \n}\n";
1423
1424 ✗ sources.push_back("#ifdef GLUP_VERTEX_SHADER\n");
1425 ✗ sources.push_back(toggle_maybe_enabled_source);
1426 ✗ sources.push_back("#else\n");
1427 ✗ Context::get_toggles_pseudo_file(sources);
1428 ✗ sources.push_back("#endif\n");
1429 ✗ }
1430 }
1431
1432 #endif
1433