GPencil: Cleanup more comments (cont)
[blender.git] / source / blender / gpu / intern / gpu_batch.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2016 by Mike Erwin.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup gpu
22  *
23  * GPU geometry batch
24  * Contains VAOs + VBOs + Shader representing a drawable entity.
25  */
26
27 #include "MEM_guardedalloc.h"
28
29 #include "GPU_batch.h"
30 #include "GPU_batch_presets.h"
31 #include "GPU_extensions.h"
32 #include "GPU_matrix.h"
33 #include "GPU_platform.h"
34 #include "GPU_shader.h"
35
36 #include "gpu_batch_private.h"
37 #include "gpu_context_private.h"
38 #include "gpu_primitive_private.h"
39 #include "gpu_shader_private.h"
40
41 #include <limits.h>
42 #include <stdlib.h>
43 #include <string.h>
44
45 static GLuint g_default_attr_vbo = 0;
46
47 static void batch_update_program_bindings(GPUBatch *batch, uint i_first);
48
49 void GPU_batch_vao_cache_clear(GPUBatch *batch)
50 {
51   if (batch->context == NULL) {
52     return;
53   }
54   if (batch->is_dynamic_vao_count) {
55     for (int i = 0; i < batch->dynamic_vaos.count; i++) {
56       if (batch->dynamic_vaos.vao_ids[i]) {
57         GPU_vao_free(batch->dynamic_vaos.vao_ids[i], batch->context);
58       }
59       if (batch->dynamic_vaos.interfaces[i]) {
60         GPU_shaderinterface_remove_batch_ref(
61             (GPUShaderInterface *)batch->dynamic_vaos.interfaces[i], batch);
62       }
63     }
64     MEM_freeN((void *)batch->dynamic_vaos.interfaces);
65     MEM_freeN(batch->dynamic_vaos.vao_ids);
66   }
67   else {
68     for (int i = 0; i < GPU_BATCH_VAO_STATIC_LEN; i++) {
69       if (batch->static_vaos.vao_ids[i]) {
70         GPU_vao_free(batch->static_vaos.vao_ids[i], batch->context);
71       }
72       if (batch->static_vaos.interfaces[i]) {
73         GPU_shaderinterface_remove_batch_ref(
74             (GPUShaderInterface *)batch->static_vaos.interfaces[i], batch);
75       }
76     }
77   }
78   batch->is_dynamic_vao_count = false;
79   for (int i = 0; i < GPU_BATCH_VAO_STATIC_LEN; i++) {
80     batch->static_vaos.vao_ids[i] = 0;
81     batch->static_vaos.interfaces[i] = NULL;
82   }
83   gpu_context_remove_batch(batch->context, batch);
84   batch->context = NULL;
85 }
86
87 GPUBatch *GPU_batch_create_ex(GPUPrimType prim_type,
88                               GPUVertBuf *verts,
89                               GPUIndexBuf *elem,
90                               uint owns_flag)
91 {
92   GPUBatch *batch = MEM_callocN(sizeof(GPUBatch), "GPUBatch");
93   GPU_batch_init_ex(batch, prim_type, verts, elem, owns_flag);
94   return batch;
95 }
96
97 void GPU_batch_init_ex(
98     GPUBatch *batch, GPUPrimType prim_type, GPUVertBuf *verts, GPUIndexBuf *elem, uint owns_flag)
99 {
100 #if TRUST_NO_ONE
101   assert(verts != NULL);
102 #endif
103
104   batch->verts[0] = verts;
105   for (int v = 1; v < GPU_BATCH_VBO_MAX_LEN; v++) {
106     batch->verts[v] = NULL;
107   }
108   for (int v = 0; v < GPU_BATCH_INST_VBO_MAX_LEN; v++) {
109     batch->inst[v] = NULL;
110   }
111   batch->elem = elem;
112   batch->gl_prim_type = convert_prim_type_to_gl(prim_type);
113   batch->phase = GPU_BATCH_READY_TO_DRAW;
114   batch->is_dynamic_vao_count = false;
115   batch->owns_flag = owns_flag;
116   batch->free_callback = NULL;
117 }
118
119 /* This will share the VBOs with the new batch. */
120 void GPU_batch_copy(GPUBatch *batch_dst, GPUBatch *batch_src)
121 {
122   GPU_batch_init_ex(batch_dst, GPU_PRIM_POINTS, batch_src->verts[0], batch_src->elem, 0);
123
124   batch_dst->gl_prim_type = batch_src->gl_prim_type;
125   for (int v = 1; v < GPU_BATCH_VBO_MAX_LEN; v++) {
126     batch_dst->verts[v] = batch_src->verts[v];
127   }
128 }
129
130 void GPU_batch_clear(GPUBatch *batch)
131 {
132   if (batch->owns_flag & GPU_BATCH_OWNS_INDEX) {
133     GPU_indexbuf_discard(batch->elem);
134   }
135   if (batch->owns_flag & GPU_BATCH_OWNS_INSTANCES) {
136     GPU_vertbuf_discard(batch->inst[0]);
137     GPU_VERTBUF_DISCARD_SAFE(batch->inst[1]);
138   }
139   if ((batch->owns_flag & ~GPU_BATCH_OWNS_INDEX) != 0) {
140     for (int v = 0; v < GPU_BATCH_VBO_MAX_LEN; v++) {
141       if (batch->verts[v] == NULL) {
142         break;
143       }
144       if (batch->owns_flag & (1 << v)) {
145         GPU_vertbuf_discard(batch->verts[v]);
146       }
147     }
148   }
149   GPU_batch_vao_cache_clear(batch);
150   batch->phase = GPU_BATCH_UNUSED;
151 }
152
153 void GPU_batch_discard(GPUBatch *batch)
154 {
155   if (batch->free_callback) {
156     batch->free_callback(batch, batch->callback_data);
157   }
158
159   GPU_batch_clear(batch);
160   MEM_freeN(batch);
161 }
162
163 void GPU_batch_callback_free_set(GPUBatch *batch,
164                                  void (*callback)(GPUBatch *, void *),
165                                  void *user_data)
166 {
167   batch->free_callback = callback;
168   batch->callback_data = user_data;
169 }
170
171 void GPU_batch_instbuf_set(GPUBatch *batch, GPUVertBuf *inst, bool own_vbo)
172 {
173 #if TRUST_NO_ONE
174   assert(inst != NULL);
175 #endif
176   /* redo the bindings */
177   GPU_batch_vao_cache_clear(batch);
178
179   if (batch->inst[0] != NULL && (batch->owns_flag & GPU_BATCH_OWNS_INSTANCES)) {
180     GPU_vertbuf_discard(batch->inst[0]);
181     GPU_VERTBUF_DISCARD_SAFE(batch->inst[1]);
182   }
183   batch->inst[0] = inst;
184
185   if (own_vbo) {
186     batch->owns_flag |= GPU_BATCH_OWNS_INSTANCES;
187   }
188   else {
189     batch->owns_flag &= ~GPU_BATCH_OWNS_INSTANCES;
190   }
191 }
192
193 void GPU_batch_elembuf_set(GPUBatch *batch, GPUIndexBuf *elem, bool own_ibo)
194 {
195   BLI_assert(elem != NULL);
196   /* redo the bindings */
197   GPU_batch_vao_cache_clear(batch);
198
199   if (batch->elem != NULL && (batch->owns_flag & GPU_BATCH_OWNS_INDEX)) {
200     GPU_indexbuf_discard(batch->elem);
201   }
202   batch->elem = elem;
203
204   if (own_ibo) {
205     batch->owns_flag |= GPU_BATCH_OWNS_INDEX;
206   }
207   else {
208     batch->owns_flag &= ~GPU_BATCH_OWNS_INDEX;
209   }
210 }
211
212 /* A bit of a quick hack. Should be streamlined as the vbos handling */
213 int GPU_batch_instbuf_add_ex(GPUBatch *batch, GPUVertBuf *insts, bool own_vbo)
214 {
215   /* redo the bindings */
216   GPU_batch_vao_cache_clear(batch);
217
218   for (uint v = 0; v < GPU_BATCH_INST_VBO_MAX_LEN; v++) {
219     if (batch->inst[v] == NULL) {
220 #if TRUST_NO_ONE
221       /* for now all VertexBuffers must have same vertex_len */
222       if (batch->inst[0] != NULL) {
223         /* Allow for different size of vertex buf (will choose the smallest number of verts). */
224         // assert(insts->vertex_len == batch->inst[0]->vertex_len);
225         assert(own_vbo == ((batch->owns_flag & GPU_BATCH_OWNS_INSTANCES) != 0));
226       }
227 #endif
228       batch->inst[v] = insts;
229       if (own_vbo) {
230         batch->owns_flag |= GPU_BATCH_OWNS_INSTANCES;
231       }
232       return v;
233     }
234   }
235
236   /* we only make it this far if there is no room for another GPUVertBuf */
237 #if TRUST_NO_ONE
238   assert(false);
239 #endif
240   return -1;
241 }
242
243 /* Returns the index of verts in the batch. */
244 int GPU_batch_vertbuf_add_ex(GPUBatch *batch, GPUVertBuf *verts, bool own_vbo)
245 {
246   /* redo the bindings */
247   GPU_batch_vao_cache_clear(batch);
248
249   for (uint v = 0; v < GPU_BATCH_VBO_MAX_LEN; v++) {
250     if (batch->verts[v] == NULL) {
251 #if TRUST_NO_ONE
252       /* for now all VertexBuffers must have same vertex_len */
253       if (batch->verts[0] != NULL) {
254         assert(verts->vertex_len == batch->verts[0]->vertex_len);
255       }
256 #endif
257       batch->verts[v] = verts;
258       /* TODO: mark dirty so we can keep attribute bindings up-to-date */
259       if (own_vbo) {
260         batch->owns_flag |= (1 << v);
261       }
262       return v;
263     }
264   }
265
266   /* we only make it this far if there is no room for another GPUVertBuf */
267 #if TRUST_NO_ONE
268   assert(false);
269 #endif
270   return -1;
271 }
272
273 static GLuint batch_vao_get(GPUBatch *batch)
274 {
275   /* Search through cache */
276   if (batch->is_dynamic_vao_count) {
277     for (int i = 0; i < batch->dynamic_vaos.count; i++) {
278       if (batch->dynamic_vaos.interfaces[i] == batch->interface) {
279         return batch->dynamic_vaos.vao_ids[i];
280       }
281     }
282   }
283   else {
284     for (int i = 0; i < GPU_BATCH_VAO_STATIC_LEN; i++) {
285       if (batch->static_vaos.interfaces[i] == batch->interface) {
286         return batch->static_vaos.vao_ids[i];
287       }
288     }
289   }
290
291   /* Set context of this batch.
292    * It will be bound to it until GPU_batch_vao_cache_clear is called.
293    * Until then it can only be drawn with this context. */
294   if (batch->context == NULL) {
295     batch->context = GPU_context_active_get();
296     gpu_context_add_batch(batch->context, batch);
297   }
298 #if TRUST_NO_ONE
299   else {
300     /* Make sure you are not trying to draw this batch in another context. */
301     assert(batch->context == GPU_context_active_get());
302   }
303 #endif
304
305   /* Cache miss, time to add a new entry! */
306   GLuint new_vao = 0;
307   if (!batch->is_dynamic_vao_count) {
308     int i; /* find first unused slot */
309     for (i = 0; i < GPU_BATCH_VAO_STATIC_LEN; i++) {
310       if (batch->static_vaos.vao_ids[i] == 0) {
311         break;
312       }
313     }
314
315     if (i < GPU_BATCH_VAO_STATIC_LEN) {
316       batch->static_vaos.interfaces[i] = batch->interface;
317       batch->static_vaos.vao_ids[i] = new_vao = GPU_vao_alloc();
318     }
319     else {
320       /* Not enough place switch to dynamic. */
321       batch->is_dynamic_vao_count = true;
322       /* Erase previous entries, they will be added back if drawn again. */
323       for (int j = 0; j < GPU_BATCH_VAO_STATIC_LEN; j++) {
324         GPU_shaderinterface_remove_batch_ref(
325             (GPUShaderInterface *)batch->static_vaos.interfaces[j], batch);
326         GPU_vao_free(batch->static_vaos.vao_ids[j], batch->context);
327       }
328       /* Init dynamic arrays and let the branch below set the values. */
329       batch->dynamic_vaos.count = GPU_BATCH_VAO_DYN_ALLOC_COUNT;
330       batch->dynamic_vaos.interfaces = MEM_callocN(
331           batch->dynamic_vaos.count * sizeof(GPUShaderInterface *), "dyn vaos interfaces");
332       batch->dynamic_vaos.vao_ids = MEM_callocN(batch->dynamic_vaos.count * sizeof(GLuint),
333                                                 "dyn vaos ids");
334     }
335   }
336
337   if (batch->is_dynamic_vao_count) {
338     int i; /* find first unused slot */
339     for (i = 0; i < batch->dynamic_vaos.count; i++) {
340       if (batch->dynamic_vaos.vao_ids[i] == 0) {
341         break;
342       }
343     }
344
345     if (i == batch->dynamic_vaos.count) {
346       /* Not enough place, realloc the array. */
347       i = batch->dynamic_vaos.count;
348       batch->dynamic_vaos.count += GPU_BATCH_VAO_DYN_ALLOC_COUNT;
349       batch->dynamic_vaos.interfaces = MEM_recallocN((void *)batch->dynamic_vaos.interfaces,
350                                                      sizeof(GPUShaderInterface *) *
351                                                          batch->dynamic_vaos.count);
352       batch->dynamic_vaos.vao_ids = MEM_recallocN(batch->dynamic_vaos.vao_ids,
353                                                   sizeof(GLuint) * batch->dynamic_vaos.count);
354     }
355     batch->dynamic_vaos.interfaces[i] = batch->interface;
356     batch->dynamic_vaos.vao_ids[i] = new_vao = GPU_vao_alloc();
357   }
358
359   GPU_shaderinterface_add_batch_ref((GPUShaderInterface *)batch->interface, batch);
360
361 #if TRUST_NO_ONE
362   assert(new_vao != 0);
363 #endif
364
365   /* We just got a fresh VAO we need to initialize it. */
366   glBindVertexArray(new_vao);
367   batch_update_program_bindings(batch, 0);
368   glBindVertexArray(0);
369
370   return new_vao;
371 }
372
373 void GPU_batch_program_set_no_use(GPUBatch *batch,
374                                   uint32_t program,
375                                   const GPUShaderInterface *shaderface)
376 {
377 #if TRUST_NO_ONE
378   assert(glIsProgram(program));
379   assert(batch->program_in_use == 0);
380 #endif
381   batch->interface = shaderface;
382   batch->program = program;
383   batch->vao_id = batch_vao_get(batch);
384 }
385
386 void GPU_batch_program_set(GPUBatch *batch, uint32_t program, const GPUShaderInterface *shaderface)
387 {
388   GPU_batch_program_set_no_use(batch, program, shaderface);
389   GPU_batch_program_use_begin(batch); /* hack! to make Batch_Uniform* simpler */
390 }
391
392 void gpu_batch_remove_interface_ref(GPUBatch *batch, const GPUShaderInterface *interface)
393 {
394   if (batch->is_dynamic_vao_count) {
395     for (int i = 0; i < batch->dynamic_vaos.count; i++) {
396       if (batch->dynamic_vaos.interfaces[i] == interface) {
397         GPU_vao_free(batch->dynamic_vaos.vao_ids[i], batch->context);
398         batch->dynamic_vaos.vao_ids[i] = 0;
399         batch->dynamic_vaos.interfaces[i] = NULL;
400         break; /* cannot have duplicates */
401       }
402     }
403   }
404   else {
405     int i;
406     for (i = 0; i < GPU_BATCH_VAO_STATIC_LEN; i++) {
407       if (batch->static_vaos.interfaces[i] == interface) {
408         GPU_vao_free(batch->static_vaos.vao_ids[i], batch->context);
409         batch->static_vaos.vao_ids[i] = 0;
410         batch->static_vaos.interfaces[i] = NULL;
411         break; /* cannot have duplicates */
412       }
413     }
414   }
415 }
416
417 static void create_bindings(GPUVertBuf *verts,
418                             const GPUShaderInterface *interface,
419                             uint16_t *attr_mask,
420                             uint v_first,
421                             const bool use_instancing)
422 {
423   const GPUVertFormat *format = &verts->format;
424
425   const uint attr_len = format->attr_len;
426   uint stride = format->stride;
427   uint offset = 0;
428
429   GPU_vertbuf_use(verts);
430
431   for (uint a_idx = 0; a_idx < attr_len; a_idx++) {
432     const GPUVertAttr *a = &format->attrs[a_idx];
433
434     if (format->deinterleaved) {
435       offset += ((a_idx == 0) ? 0 : format->attrs[a_idx - 1].sz) * verts->vertex_len;
436       stride = a->sz;
437     }
438     else {
439       offset = a->offset;
440     }
441
442     const GLvoid *pointer = (const GLubyte *)0 + offset + v_first * stride;
443
444     for (uint n_idx = 0; n_idx < a->name_len; n_idx++) {
445       const char *name = GPU_vertformat_attr_name_get(format, a, n_idx);
446       const GPUShaderInput *input = GPU_shaderinterface_attr(interface, name);
447
448       if (input == NULL) {
449         continue;
450       }
451
452       *attr_mask &= ~(1 << input->location);
453
454       if (a->comp_len == 16 || a->comp_len == 12 || a->comp_len == 8) {
455 #if TRUST_NO_ONE
456         assert(a->fetch_mode == GPU_FETCH_FLOAT);
457         assert(a->gl_comp_type == GL_FLOAT);
458 #endif
459         for (int i = 0; i < a->comp_len / 4; i++) {
460           glEnableVertexAttribArray(input->location + i);
461           glVertexAttribDivisor(input->location + i, (use_instancing) ? 1 : 0);
462           glVertexAttribPointer(input->location + i,
463                                 4,
464                                 a->gl_comp_type,
465                                 GL_FALSE,
466                                 stride,
467                                 (const GLubyte *)pointer + i * 16);
468         }
469       }
470       else {
471         glEnableVertexAttribArray(input->location);
472         glVertexAttribDivisor(input->location, (use_instancing) ? 1 : 0);
473
474         switch (a->fetch_mode) {
475           case GPU_FETCH_FLOAT:
476           case GPU_FETCH_INT_TO_FLOAT:
477             glVertexAttribPointer(
478                 input->location, a->comp_len, a->gl_comp_type, GL_FALSE, stride, pointer);
479             break;
480           case GPU_FETCH_INT_TO_FLOAT_UNIT:
481             glVertexAttribPointer(
482                 input->location, a->comp_len, a->gl_comp_type, GL_TRUE, stride, pointer);
483             break;
484           case GPU_FETCH_INT:
485             glVertexAttribIPointer(input->location, a->comp_len, a->gl_comp_type, stride, pointer);
486             break;
487         }
488       }
489     }
490   }
491 }
492
493 static void batch_update_program_bindings(GPUBatch *batch, uint i_first)
494 {
495   uint16_t attr_mask = batch->interface->enabled_attr_mask;
496
497   /* Reverse order so first VBO'S have more prevalence (in term of attribute override). */
498   for (int v = GPU_BATCH_VBO_MAX_LEN - 1; v > -1; v--) {
499     if (batch->verts[v] != NULL) {
500       create_bindings(batch->verts[v], batch->interface, &attr_mask, 0, false);
501     }
502   }
503
504   for (int v = GPU_BATCH_INST_VBO_MAX_LEN - 1; v > -1; v--) {
505     if (batch->inst[v]) {
506       create_bindings(batch->inst[v], batch->interface, &attr_mask, i_first, true);
507     }
508   }
509
510   if (attr_mask != 0 && GLEW_ARB_vertex_attrib_binding) {
511     for (uint16_t mask = 1, a = 0; a < 16; a++, mask <<= 1) {
512       if (attr_mask & mask) {
513         /* This replaces glVertexAttrib4f(a, 0.0f, 0.0f, 0.0f, 1.0f); with a more modern style.
514          * Fix issues for some drivers (see T75069). */
515         glBindVertexBuffer(a, g_default_attr_vbo, (intptr_t)0, (intptr_t)0);
516
517         glEnableVertexAttribArray(a);
518         glVertexAttribFormat(a, 4, GL_FLOAT, GL_FALSE, 0);
519         glVertexAttribBinding(a, a);
520       }
521     }
522   }
523
524   if (batch->elem) {
525     GPU_indexbuf_use(batch->elem);
526   }
527 }
528
529 void GPU_batch_program_use_begin(GPUBatch *batch)
530 {
531   /* NOTE: use_program & done_using_program are fragile, depend on staying in sync with
532    *       the GL context's active program.
533    *       use_program doesn't mark other programs as "not used". */
534   /* TODO: make not fragile (somehow) */
535
536   if (!batch->program_in_use) {
537     glUseProgram(batch->program);
538     batch->program_in_use = true;
539   }
540 }
541
542 void GPU_batch_program_use_end(GPUBatch *batch)
543 {
544   if (batch->program_in_use) {
545 #if PROGRAM_NO_OPTI
546     glUseProgram(0);
547 #endif
548     batch->program_in_use = false;
549   }
550 }
551
552 #if TRUST_NO_ONE
553 #  define GET_UNIFORM \
554     const GPUShaderInput *uniform = GPU_shaderinterface_uniform(batch->interface, name); \
555     assert(uniform);
556 #else
557 #  define GET_UNIFORM \
558     const GPUShaderInput *uniform = GPU_shaderinterface_uniform(batch->interface, name);
559 #endif
560
561 void GPU_batch_uniform_1ui(GPUBatch *batch, const char *name, uint value)
562 {
563   GET_UNIFORM
564   glUniform1ui(uniform->location, value);
565 }
566
567 void GPU_batch_uniform_1i(GPUBatch *batch, const char *name, int value)
568 {
569   GET_UNIFORM
570   glUniform1i(uniform->location, value);
571 }
572
573 void GPU_batch_uniform_1b(GPUBatch *batch, const char *name, bool value)
574 {
575   GET_UNIFORM
576   glUniform1i(uniform->location, value ? GL_TRUE : GL_FALSE);
577 }
578
579 void GPU_batch_uniform_2f(GPUBatch *batch, const char *name, float x, float y)
580 {
581   GET_UNIFORM
582   glUniform2f(uniform->location, x, y);
583 }
584
585 void GPU_batch_uniform_3f(GPUBatch *batch, const char *name, float x, float y, float z)
586 {
587   GET_UNIFORM
588   glUniform3f(uniform->location, x, y, z);
589 }
590
591 void GPU_batch_uniform_4f(GPUBatch *batch, const char *name, float x, float y, float z, float w)
592 {
593   GET_UNIFORM
594   glUniform4f(uniform->location, x, y, z, w);
595 }
596
597 void GPU_batch_uniform_1f(GPUBatch *batch, const char *name, float x)
598 {
599   GET_UNIFORM
600   glUniform1f(uniform->location, x);
601 }
602
603 void GPU_batch_uniform_2fv(GPUBatch *batch, const char *name, const float data[2])
604 {
605   GET_UNIFORM
606   glUniform2fv(uniform->location, 1, data);
607 }
608
609 void GPU_batch_uniform_3fv(GPUBatch *batch, const char *name, const float data[3])
610 {
611   GET_UNIFORM
612   glUniform3fv(uniform->location, 1, data);
613 }
614
615 void GPU_batch_uniform_4fv(GPUBatch *batch, const char *name, const float data[4])
616 {
617   GET_UNIFORM
618   glUniform4fv(uniform->location, 1, data);
619 }
620
621 void GPU_batch_uniform_2fv_array(GPUBatch *batch,
622                                  const char *name,
623                                  const int len,
624                                  const float *data)
625 {
626   GET_UNIFORM
627   glUniform2fv(uniform->location, len, data);
628 }
629
630 void GPU_batch_uniform_4fv_array(GPUBatch *batch,
631                                  const char *name,
632                                  const int len,
633                                  const float *data)
634 {
635   GET_UNIFORM
636   glUniform4fv(uniform->location, len, data);
637 }
638
639 void GPU_batch_uniform_mat4(GPUBatch *batch, const char *name, const float data[4][4])
640 {
641   GET_UNIFORM
642   glUniformMatrix4fv(uniform->location, 1, GL_FALSE, (const float *)data);
643 }
644
645 static void *elem_offset(const GPUIndexBuf *el, int v_first)
646 {
647 #if GPU_TRACK_INDEX_RANGE
648   if (el->index_type == GPU_INDEX_U16) {
649     return (GLushort *)0 + v_first + el->index_start;
650   }
651 #endif
652   return (GLuint *)0 + v_first + el->index_start;
653 }
654
655 /* Use when drawing with GPU_batch_draw_advanced */
656 void GPU_batch_bind(GPUBatch *batch)
657 {
658   glBindVertexArray(batch->vao_id);
659
660 #if GPU_TRACK_INDEX_RANGE
661   /* Can be removed if GL 4.3 is required. */
662   if (!GLEW_ARB_ES3_compatibility && batch->elem != NULL) {
663     GLuint restart_index = (batch->elem->index_type == GPU_INDEX_U16) ? (GLuint)0xFFFF :
664                                                                         (GLuint)0xFFFFFFFF;
665     glPrimitiveRestartIndex(restart_index);
666   }
667 #endif
668 }
669
670 void GPU_batch_draw(GPUBatch *batch)
671 {
672 #if TRUST_NO_ONE
673   assert(batch->phase == GPU_BATCH_READY_TO_DRAW);
674   assert(batch->verts[0]->vbo_id != 0);
675 #endif
676   GPU_batch_program_use_begin(batch);
677   GPU_matrix_bind(batch->interface);  // external call.
678   GPU_shader_set_srgb_uniform(batch->interface);
679
680   GPU_batch_bind(batch);
681   GPU_batch_draw_advanced(batch, 0, 0, 0, 0);
682
683   GPU_batch_program_use_end(batch);
684 }
685
686 #if GPU_TRACK_INDEX_RANGE
687 #  define BASE_INDEX(el) ((el)->base_index)
688 #  define INDEX_TYPE(el) ((el)->gl_index_type)
689 #else
690 #  define BASE_INDEX(el) 0
691 #  define INDEX_TYPE(el) GL_UNSIGNED_INT
692 #endif
693
694 void GPU_batch_draw_advanced(GPUBatch *batch, int v_first, int v_count, int i_first, int i_count)
695 {
696   BLI_assert(batch->program_in_use);
697   /* TODO could assert that VAO is bound. */
698
699   if (v_count == 0) {
700     v_count = (batch->elem) ? batch->elem->index_len : batch->verts[0]->vertex_len;
701   }
702   if (i_count == 0) {
703     i_count = (batch->inst[0]) ? batch->inst[0]->vertex_len : 1;
704     /* Meh. This is to be able to use different numbers of verts in instance vbos. */
705     if (batch->inst[1] && i_count > batch->inst[1]->vertex_len) {
706       i_count = batch->inst[1]->vertex_len;
707     }
708   }
709
710   if (v_count == 0 || i_count == 0) {
711     /* Nothing to draw. */
712     return;
713   }
714
715   /* Verify there is enough data do draw. */
716   /* TODO(fclem) Nice to have but this is invalid when using procedural draw-calls.
717    * The right assert would be to check if there is an enabled attribute from each VBO
718    * and check their length. */
719   // BLI_assert(i_first + i_count <= (batch->inst ? batch->inst->vertex_len : INT_MAX));
720   // BLI_assert(v_first + v_count <=
721   //            (batch->elem ? batch->elem->index_len : batch->verts[0]->vertex_len));
722
723 #ifdef __APPLE__
724   GLuint vao = 0;
725 #endif
726
727   if (!GPU_arb_base_instance_is_supported()) {
728     if (i_first > 0) {
729 #ifdef __APPLE__
730       /**
731        * There seems to be a nasty bug when drawing using the same VAO reconfiguring. (see T71147)
732        * We just use a throwaway VAO for that. Note that this is likely to degrade performance.
733        **/
734       glGenVertexArrays(1, &vao);
735       glBindVertexArray(vao);
736 #else
737       /* If using offset drawing with instancing, we must
738        * use the default VAO and redo bindings. */
739       glBindVertexArray(GPU_vao_default());
740 #endif
741       batch_update_program_bindings(batch, i_first);
742     }
743     else {
744       /* Previous call could have bind the default vao
745        * see above. */
746       glBindVertexArray(batch->vao_id);
747     }
748   }
749
750   if (batch->elem) {
751     const GPUIndexBuf *el = batch->elem;
752     GLenum index_type = INDEX_TYPE(el);
753     GLint base_index = BASE_INDEX(el);
754     void *v_first_ofs = elem_offset(el, v_first);
755
756     if (GPU_arb_base_instance_is_supported()) {
757       glDrawElementsInstancedBaseVertexBaseInstance(
758           batch->gl_prim_type, v_count, index_type, v_first_ofs, i_count, base_index, i_first);
759     }
760     else {
761       glDrawElementsInstancedBaseVertex(
762           batch->gl_prim_type, v_count, index_type, v_first_ofs, i_count, base_index);
763     }
764   }
765   else {
766 #ifdef __APPLE__
767     glDisable(GL_PRIMITIVE_RESTART);
768 #endif
769     if (GPU_arb_base_instance_is_supported()) {
770       glDrawArraysInstancedBaseInstance(batch->gl_prim_type, v_first, v_count, i_count, i_first);
771     }
772     else {
773       glDrawArraysInstanced(batch->gl_prim_type, v_first, v_count, i_count);
774     }
775 #ifdef __APPLE__
776     glEnable(GL_PRIMITIVE_RESTART);
777 #endif
778   }
779
780 #ifdef __APPLE__
781   if (vao != 0) {
782     glDeleteVertexArrays(1, &vao);
783   }
784 #endif
785 }
786
787 /* just draw some vertices and let shader place them where we want. */
788 void GPU_draw_primitive(GPUPrimType prim_type, int v_count)
789 {
790   /* we cannot draw without vao ... annoying ... */
791   glBindVertexArray(GPU_vao_default());
792
793   GLenum type = convert_prim_type_to_gl(prim_type);
794   glDrawArrays(type, 0, v_count);
795
796   /* Performance hog if you are drawing with the same vao multiple time.
797    * Only activate for debugging.*/
798   // glBindVertexArray(0);
799 }
800
801 /* -------------------------------------------------------------------- */
802 /** \name Indirect Draw Calls
803  * \{ */
804
805 #if 0
806 #  define USE_MULTI_DRAW_INDIRECT 0
807 #else
808 #  define USE_MULTI_DRAW_INDIRECT \
809     (GL_ARB_multi_draw_indirect && GPU_arb_base_instance_is_supported())
810 #endif
811
812 typedef struct GPUDrawCommand {
813   uint v_count;
814   uint i_count;
815   uint v_first;
816   uint i_first;
817 } GPUDrawCommand;
818
819 typedef struct GPUDrawCommandIndexed {
820   uint v_count;
821   uint i_count;
822   uint v_first;
823   uint base_index;
824   uint i_first;
825 } GPUDrawCommandIndexed;
826
827 struct GPUDrawList {
828   GPUBatch *batch;
829   uint base_index;  /* Avoid dereferencing batch. */
830   uint cmd_offset;  /* in bytes, offset  inside indirect command buffer. */
831   uint cmd_len;     /* Number of used command for the next call. */
832   uint buffer_size; /* in bytes, size of indirect command buffer. */
833   GLuint buffer_id; /* Draw Indirect Buffer id */
834   union {
835     GPUDrawCommand *commands;
836     GPUDrawCommandIndexed *commands_indexed;
837   };
838 };
839
840 GPUDrawList *GPU_draw_list_create(int length)
841 {
842   GPUDrawList *list = MEM_callocN(sizeof(GPUDrawList), "GPUDrawList");
843   /* Alloc the biggest possible command list which is indexed. */
844   list->buffer_size = sizeof(GPUDrawCommandIndexed) * length;
845   if (USE_MULTI_DRAW_INDIRECT) {
846     list->buffer_id = GPU_buf_alloc();
847     glBindBuffer(GL_DRAW_INDIRECT_BUFFER, list->buffer_id);
848     glBufferData(GL_DRAW_INDIRECT_BUFFER, list->buffer_size, NULL, GL_DYNAMIC_DRAW);
849   }
850   else {
851     list->commands = MEM_mallocN(list->buffer_size, "GPUDrawList data");
852   }
853   return list;
854 }
855
856 void GPU_draw_list_discard(GPUDrawList *list)
857 {
858   if (list->buffer_id) {
859     GPU_buf_free(list->buffer_id);
860   }
861   else {
862     MEM_SAFE_FREE(list->commands);
863   }
864   MEM_freeN(list);
865 }
866
867 void GPU_draw_list_init(GPUDrawList *list, GPUBatch *batch)
868 {
869   BLI_assert(batch->phase == GPU_BATCH_READY_TO_DRAW);
870   list->batch = batch;
871   list->base_index = batch->elem ? BASE_INDEX(batch->elem) : UINT_MAX;
872   list->cmd_len = 0;
873
874   if (USE_MULTI_DRAW_INDIRECT) {
875     if (list->commands == NULL) {
876       glBindBuffer(GL_DRAW_INDIRECT_BUFFER, list->buffer_id);
877       if (list->cmd_offset >= list->buffer_size) {
878         /* Orphan buffer data and start fresh. */
879         glBufferData(GL_DRAW_INDIRECT_BUFFER, list->buffer_size, NULL, GL_DYNAMIC_DRAW);
880         list->cmd_offset = 0;
881       }
882       GLenum flags = GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_FLUSH_EXPLICIT_BIT;
883       list->commands = glMapBufferRange(
884           GL_DRAW_INDIRECT_BUFFER, list->cmd_offset, list->buffer_size - list->cmd_offset, flags);
885     }
886   }
887   else {
888     list->cmd_offset = 0;
889   }
890 }
891
892 void GPU_draw_list_command_add(
893     GPUDrawList *list, int v_first, int v_count, int i_first, int i_count)
894 {
895   BLI_assert(list->commands);
896
897   if (v_count == 0 || i_count == 0) {
898     return;
899   }
900
901   if (list->base_index != UINT_MAX) {
902     GPUDrawCommandIndexed *cmd = list->commands_indexed + list->cmd_len;
903     cmd->v_first = v_first;
904     cmd->v_count = v_count;
905     cmd->i_count = i_count;
906     cmd->base_index = list->base_index;
907     cmd->i_first = i_first;
908   }
909   else {
910     GPUDrawCommand *cmd = list->commands + list->cmd_len;
911     cmd->v_first = v_first;
912     cmd->v_count = v_count;
913     cmd->i_count = i_count;
914     cmd->i_first = i_first;
915   }
916
917   list->cmd_len++;
918   uint offset = list->cmd_offset + list->cmd_len * sizeof(GPUDrawCommandIndexed);
919
920   if (offset == list->buffer_size) {
921     GPU_draw_list_submit(list);
922     GPU_draw_list_init(list, list->batch);
923   }
924 }
925
926 void GPU_draw_list_submit(GPUDrawList *list)
927 {
928   GPUBatch *batch = list->batch;
929
930   if (list->cmd_len == 0) {
931     return;
932   }
933
934   BLI_assert(list->commands);
935   BLI_assert(batch->program_in_use);
936   /* TODO could assert that VAO is bound. */
937
938   /* TODO We loose a bit of memory here if we only draw arrays. Fix that. */
939   uintptr_t offset = list->cmd_offset;
940   uint cmd_len = list->cmd_len;
941   size_t bytes_used = cmd_len * sizeof(GPUDrawCommandIndexed);
942   list->cmd_len = 0; /* Avoid reuse. */
943
944   /* Only do multi-draw indirect if doing more than 2 drawcall.
945    * This avoids the overhead of buffer mapping if scene is
946    * not very instance friendly.
947    * BUT we also need to take into account the case where only
948    * a few instances are needed to finish filling a call buffer. */
949   const bool do_mdi = (cmd_len > 2) || (list->cmd_offset + bytes_used == list->buffer_size);
950
951   if (USE_MULTI_DRAW_INDIRECT && do_mdi) {
952     GLenum prim = batch->gl_prim_type;
953
954     glBindBuffer(GL_DRAW_INDIRECT_BUFFER, list->buffer_id);
955     glFlushMappedBufferRange(GL_DRAW_INDIRECT_BUFFER, 0, bytes_used);
956     glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER);
957     list->commands = NULL; /* Unmapped */
958     list->cmd_offset += bytes_used;
959
960     if (batch->elem) {
961       glMultiDrawElementsIndirect(prim, INDEX_TYPE(batch->elem), (void *)offset, cmd_len, 0);
962     }
963     else {
964       glMultiDrawArraysIndirect(prim, (void *)offset, cmd_len, 0);
965     }
966   }
967   else {
968     /* Fallback */
969     if (batch->elem) {
970       GPUDrawCommandIndexed *cmd = list->commands_indexed;
971       for (int i = 0; i < cmd_len; i++, cmd++) {
972         /* Index start was added by Draw manager. Avoid counting it twice. */
973         cmd->v_first -= batch->elem->index_start;
974         GPU_batch_draw_advanced(batch, cmd->v_first, cmd->v_count, cmd->i_first, cmd->i_count);
975       }
976     }
977     else {
978       GPUDrawCommand *cmd = list->commands;
979       for (int i = 0; i < cmd_len; i++, cmd++) {
980         GPU_batch_draw_advanced(batch, cmd->v_first, cmd->v_count, cmd->i_first, cmd->i_count);
981       }
982     }
983   }
984 }
985
986 /** \} */
987
988 /* -------------------------------------------------------------------- */
989 /** \name Utilities
990  * \{ */
991
992 void GPU_batch_program_set_shader(GPUBatch *batch, GPUShader *shader)
993 {
994   GPU_batch_program_set(batch, shader->program, shader->interface);
995 }
996
997 void GPU_batch_program_set_builtin_with_config(GPUBatch *batch,
998                                                eGPUBuiltinShader shader_id,
999                                                eGPUShaderConfig sh_cfg)
1000 {
1001   GPUShader *shader = GPU_shader_get_builtin_shader_with_config(shader_id, sh_cfg);
1002   GPU_batch_program_set(batch, shader->program, shader->interface);
1003 }
1004
1005 void GPU_batch_program_set_builtin(GPUBatch *batch, eGPUBuiltinShader shader_id)
1006 {
1007   GPU_batch_program_set_builtin_with_config(batch, shader_id, GPU_SHADER_CFG_DEFAULT);
1008 }
1009
1010 /* Bind program bound to IMM to the batch.
1011  * XXX Use this with much care. Drawing with the GPUBatch API is not compatible with IMM.
1012  * DO NOT DRAW WITH THE BATCH BEFORE CALLING immUnbindProgram. */
1013 void GPU_batch_program_set_imm_shader(GPUBatch *batch)
1014 {
1015   GLuint program;
1016   GPUShaderInterface *interface;
1017   immGetProgram(&program, &interface);
1018   GPU_batch_program_set(batch, program, interface);
1019 }
1020
1021 /** \} */
1022
1023 /* -------------------------------------------------------------------- */
1024 /** \name Init/Exit
1025  * \{ */
1026
1027 void gpu_batch_init(void)
1028 {
1029   if (g_default_attr_vbo == 0) {
1030     g_default_attr_vbo = GPU_buf_alloc();
1031
1032     float default_attrib_data[4] = {0.0f, 0.0f, 0.0f, 1.0f};
1033     glBindBuffer(GL_ARRAY_BUFFER, g_default_attr_vbo);
1034     glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 4, default_attrib_data, GL_STATIC_DRAW);
1035     glBindBuffer(GL_ARRAY_BUFFER, 0);
1036   }
1037
1038   gpu_batch_presets_init();
1039 }
1040
1041 void gpu_batch_exit(void)
1042 {
1043   GPU_buf_free(g_default_attr_vbo);
1044   g_default_attr_vbo = 0;
1045
1046   gpu_batch_presets_exit();
1047 }
1048
1049 /** \} */