Blender  V3.3
overlay_shader.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2019 Blender Foundation. */
3 
8 #include "DRW_render.h"
9 
10 #include "GPU_shader.h"
11 
12 #include "UI_resources.h"
13 
14 #include "overlay_private.h"
15 
16 typedef struct OVERLAY_Shaders {
106 
107 static struct {
109 } e_data = {{{NULL}}};
110 
112 {
113  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
114  if (!sh_data->antialiasing) {
115  sh_data->antialiasing = GPU_shader_create_from_info_name("overlay_antialiasing");
116  }
117  return sh_data->antialiasing;
118 }
119 
121 {
122  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
123  if (!sh_data->background) {
124  sh_data->background = GPU_shader_create_from_info_name("overlay_background");
125  }
126  return sh_data->background;
127 }
128 
130 {
131  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
132  if (!sh_data->clipbound) {
133  sh_data->clipbound = GPU_shader_create_from_info_name("overlay_clipbound");
134  }
135  return sh_data->clipbound;
136 }
137 
139 {
140  const DRWContextState *draw_ctx = DRW_context_state_get();
141  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
142  if (!sh_data->depth_only) {
144  draw_ctx->sh_cfg ? "overlay_depth_only_clipped" : "overlay_depth_only");
145  }
146  return sh_data->depth_only;
147 }
148 
150 {
151  const DRWContextState *draw_ctx = DRW_context_state_get();
152  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
153  if (!sh_data->edit_mesh_vert) {
155  draw_ctx->sh_cfg ? "overlay_edit_mesh_vert_clipped" : "overlay_edit_mesh_vert");
156  }
157  return sh_data->edit_mesh_vert;
158 }
159 
161 {
162  const DRWContextState *draw_ctx = DRW_context_state_get();
163  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
164  GPUShader **sh = use_flat_interp ? &sh_data->edit_mesh_edge_flat : &sh_data->edit_mesh_edge;
165  if (*sh == NULL) {
167  draw_ctx->sh_cfg ?
168  (use_flat_interp ? "overlay_edit_mesh_edge_flat_clipped" :
169  "overlay_edit_mesh_edge_clipped") :
170  (use_flat_interp ? "overlay_edit_mesh_edge_flat" : "overlay_edit_mesh_edge"));
171  }
172  return *sh;
173 }
174 
176 {
177  const DRWContextState *draw_ctx = DRW_context_state_get();
178  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
179  if (use_outline && !sh_data->armature_sphere_outline) {
181  draw_ctx->sh_cfg ? "overlay_armature_sphere_outline_clipped" :
182  "overlay_armature_sphere_outline");
183  }
184  else if (!sh_data->armature_sphere_solid) {
186  draw_ctx->sh_cfg ? "overlay_armature_sphere_solid_clipped" :
187  "overlay_armature_sphere_solid");
188  }
190 }
191 
193 {
194  const DRWContextState *draw_ctx = DRW_context_state_get();
195  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
196  if (use_outline && !sh_data->armature_shape_outline) {
198  draw_ctx->sh_cfg ? "overlay_armature_shape_outline_clipped" :
199  "overlay_armature_shape_outline");
200  }
201  else if (!sh_data->armature_shape_solid) {
203  draw_ctx->sh_cfg ? "overlay_armature_shape_solid_clipped" :
204  "overlay_armature_shape_solid");
205  }
207 }
208 
210 {
211  const DRWContextState *draw_ctx = DRW_context_state_get();
212  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
215  draw_ctx->sh_cfg ? "overlay_armature_shape_wire_clipped" : "overlay_armature_shape_wire");
216  }
218 }
219 
221 {
222  const DRWContextState *draw_ctx = DRW_context_state_get();
223  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
224  if (use_outline && !sh_data->armature_envelope_outline) {
226  draw_ctx->sh_cfg ? "overlay_armature_envelope_outline_clipped" :
227  "overlay_armature_envelope_outline");
228  }
229  else if (!sh_data->armature_envelope_solid) {
231  draw_ctx->sh_cfg ? "overlay_armature_envelope_solid_clipped" :
232  "overlay_armature_envelope_solid");
233  }
235 }
236 
238 {
239  const DRWContextState *draw_ctx = DRW_context_state_get();
240  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
241  if (!sh_data->armature_stick) {
243  draw_ctx->sh_cfg ? "overlay_armature_stick_clipped" : "overlay_armature_stick");
244  }
245  return sh_data->armature_stick;
246 }
247 
249 {
250  const DRWContextState *draw_ctx = DRW_context_state_get();
251  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
252  if (!sh_data->armature_dof_wire) {
254  draw_ctx->sh_cfg ? "overlay_armature_dof_wire_clipped" : "overlay_armature_dof_wire");
255  }
256  return sh_data->armature_dof_wire;
257 }
258 
260 {
261  const DRWContextState *draw_ctx = DRW_context_state_get();
262  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
263  if (!sh_data->armature_dof_solid) {
265  draw_ctx->sh_cfg ? "overlay_armature_dof_solid_clipped" : "overlay_armature_dof_solid");
266  }
267  return sh_data->armature_dof_solid;
268 }
269 
271 {
272  const DRWContextState *draw_ctx = DRW_context_state_get();
273  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
274  if (!sh_data->armature_wire) {
276  draw_ctx->sh_cfg ? "overlay_armature_wire_clipped" : "overlay_armature_wire");
277  }
278  return sh_data->armature_wire;
279 }
280 
282 {
283  const DRWContextState *draw_ctx = DRW_context_state_get();
284  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
285  if (!sh_data->edit_curve_handle) {
287  draw_ctx->sh_cfg ? "overlay_edit_curve_handle_clipped" : "overlay_edit_curve_handle");
288  }
289  return sh_data->edit_curve_handle;
290 }
291 
293 {
294  const DRWContextState *draw_ctx = DRW_context_state_get();
295  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
296  if (!sh_data->edit_curve_point) {
298  draw_ctx->sh_cfg ? "overlay_edit_curve_point_clipped" : "overlay_edit_curve_point");
299  }
300  return sh_data->edit_curve_point;
301 }
302 
304 {
305  const DRWContextState *draw_ctx = DRW_context_state_get();
306  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
307  if (!sh_data->edit_curve_wire) {
309  draw_ctx->sh_cfg ? "overlay_edit_curve_wire_clipped" : "overlay_edit_curve_wire");
310  }
311  return sh_data->edit_curve_wire;
312 }
313 
315 {
316  const DRWContextState *draw_ctx = DRW_context_state_get();
317  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
320  draw_ctx->sh_cfg ? "overlay_edit_gpencil_guide_point_clipped" :
321  "overlay_edit_gpencil_guide_point");
322  }
324 }
325 
327 {
328  const DRWContextState *draw_ctx = DRW_context_state_get();
329  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
330  if (!sh_data->edit_gpencil_point) {
332  draw_ctx->sh_cfg ? "overlay_edit_gpencil_point_clipped" : "overlay_edit_gpencil_point");
333  }
334  return sh_data->edit_gpencil_point;
335 }
336 
338 {
339  const DRWContextState *draw_ctx = DRW_context_state_get();
340  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
341  if (!sh_data->edit_gpencil_wire) {
343  draw_ctx->sh_cfg ? "overlay_edit_gpencil_wire_clipped" : "overlay_edit_gpencil_wire");
344  }
345  return sh_data->edit_gpencil_wire;
346 }
347 
349 {
350  const DRWContextState *draw_ctx = DRW_context_state_get();
351  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
352  if (!sh_data->edit_lattice_point) {
354  draw_ctx->sh_cfg ? "overlay_edit_lattice_point_clipped" : "overlay_edit_lattice_point");
355  }
356  return sh_data->edit_lattice_point;
357 }
358 
360 {
361  const DRWContextState *draw_ctx = DRW_context_state_get();
362  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
363  if (!sh_data->edit_lattice_wire) {
365  draw_ctx->sh_cfg ? "overlay_edit_lattice_wire_clipped" : "overlay_edit_lattice_wire");
366  }
367  return sh_data->edit_lattice_wire;
368 }
369 
371 {
372  const DRWContextState *draw_ctx = DRW_context_state_get();
373  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
374  if (!sh_data->edit_mesh_face) {
376  draw_ctx->sh_cfg ? "overlay_edit_mesh_face_clipped" : "overlay_edit_mesh_face");
377  }
378  return sh_data->edit_mesh_face;
379 }
380 
382 {
383  const DRWContextState *draw_ctx = DRW_context_state_get();
384  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
385  if (!sh_data->edit_mesh_facedot) {
387  draw_ctx->sh_cfg ? "overlay_edit_mesh_facedot_clipped" : "overlay_edit_mesh_facedot");
388  }
389  return sh_data->edit_mesh_facedot;
390 }
391 
393 {
394  const DRWContextState *draw_ctx = DRW_context_state_get();
395  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
396  if (!sh_data->edit_mesh_normals) {
398  draw_ctx->sh_cfg ? "overlay_edit_mesh_normal_clipped" : "overlay_edit_mesh_normal");
399  }
400  return sh_data->edit_mesh_normals;
401 }
402 
404 {
405  const DRWContextState *draw_ctx = DRW_context_state_get();
406  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
407  if (!sh_data->edit_mesh_analysis) {
409  draw_ctx->sh_cfg ? "overlay_edit_mesh_analysis_clipped" : "overlay_edit_mesh_analysis");
410  }
411  return sh_data->edit_mesh_analysis;
412 }
413 
415 {
416  const DRWContextState *draw_ctx = DRW_context_state_get();
417  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
420  draw_ctx->sh_cfg ? "overlay_edit_mesh_skin_root_clipped" : "overlay_edit_mesh_skin_root");
421  }
423 }
424 
426 {
427  const DRWContextState *draw_ctx = DRW_context_state_get();
428  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
431  draw_ctx->sh_cfg ? "overlay_edit_particle_strand_clipped" :
432  "overlay_edit_particle_strand");
433  }
435 }
436 
438 {
439  const DRWContextState *draw_ctx = DRW_context_state_get();
440  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
443  draw_ctx->sh_cfg ? "overlay_edit_particle_point_clipped" : "overlay_edit_particle_point");
444  }
446 }
447 
449 {
450  const DRWContextState *draw_ctx = DRW_context_state_get();
451  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
452  GPUShader **sh = (is_select) ? &sh_data->extra_select : &sh_data->extra;
453  if (!*sh) {
455  draw_ctx->sh_cfg ? (is_select ? "overlay_extra_select_clipped" : "overlay_extra_clipped") :
456  (is_select ? "overlay_extra_select" : "overlay_extra"));
457  }
458  return *sh;
459 }
460 
462 {
463  const DRWContextState *draw_ctx = DRW_context_state_get();
464  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
467  draw_ctx->sh_cfg ? "overlay_extra_grid_clipped" : "overlay_extra_grid");
468  }
470 }
471 
473 {
474  const DRWContextState *draw_ctx = DRW_context_state_get();
475  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
476  if (!sh_data->extra_groundline) {
478  draw_ctx->sh_cfg ? "overlay_extra_groundline_clipped" : "overlay_extra_groundline");
479  }
480  return sh_data->extra_groundline;
481 }
482 
483 GPUShader *OVERLAY_shader_extra_wire(bool use_object, bool is_select)
484 {
485  const DRWContextState *draw_ctx = DRW_context_state_get();
486  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
487  GPUShader **sh = (is_select) ? &sh_data->extra_wire_select : &sh_data->extra_wire[use_object];
488  if (!*sh) {
489  const char *info_name = NULL;
490  if (draw_ctx->sh_cfg) {
491  if (is_select) {
492  info_name = "overlay_extra_wire_select_clipped";
493  }
494  else {
495  info_name = use_object ? "overlay_extra_wire_object_clipped" :
496  "overlay_extra_wire_clipped";
497  }
498  }
499  else {
500  if (is_select) {
501  info_name = "overlay_extra_wire_select";
502  }
503  else {
504  info_name = use_object ? "overlay_extra_wire_object" : "overlay_extra_wire";
505  }
506  }
507  *sh = GPU_shader_create_from_info_name(info_name);
508  }
509  return *sh;
510 }
511 
513 {
514  const DRWContextState *draw_ctx = DRW_context_state_get();
515  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
516  if (!sh_data->extra_loose_point) {
518  draw_ctx->sh_cfg ? "overlay_extra_loose_point_clipped" : "overlay_extra_loose_point");
519  }
520  return sh_data->extra_loose_point;
521 }
522 
524 {
525  const DRWContextState *draw_ctx = DRW_context_state_get();
526  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
527  if (!sh_data->extra_point) {
529  draw_ctx->sh_cfg ? "overlay_extra_point_clipped" : "overlay_extra_point");
530  }
531  return sh_data->extra_point;
532 }
533 
535 {
536  const DRWContextState *draw_ctx = DRW_context_state_get();
537  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
538  if (!sh_data->facing) {
540  draw_ctx->sh_cfg ? "overlay_facing_clipped" : "overlay_facing");
541  }
542  return sh_data->facing;
543 }
544 
546 {
547  const DRWContextState *draw_ctx = DRW_context_state_get();
548  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
549  if (!sh_data->gpencil_canvas) {
550  /* TODO(fclem): Support Clipping? Everything is already setup but don't want to change behavior
551  * without agreement of all gpencil module. */
553  0 ? "overlay_gpencil_canvas_clipped" : "overlay_gpencil_canvas");
554  }
555  return sh_data->gpencil_canvas;
556 }
557 
559 {
560  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
561  if (!sh_data->grid) {
562  sh_data->grid = GPU_shader_create_from_info_name("overlay_grid");
563  }
564  return sh_data->grid;
565 }
566 
568 {
569  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
570  if (!sh_data->grid_background) {
571  sh_data->grid_background = GPU_shader_create_from_info_name("overlay_grid_background");
572  }
573  return sh_data->grid_background;
574 }
575 
577 {
578  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
579  if (!sh_data->grid_image) {
580  sh_data->grid_image = GPU_shader_create_from_info_name("overlay_grid_image");
581  }
582  return sh_data->grid_image;
583 }
584 
586 {
587  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
590  "overlay_edit_uv_stencil_image");
591  }
593 }
594 
596 {
597  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
598  if (!sh_data->edit_uv_mask_image) {
599  sh_data->edit_uv_mask_image = GPU_shader_create_from_info_name("overlay_edit_uv_mask_image");
600  }
601  return sh_data->edit_uv_mask_image;
602 }
603 
605 {
606  const DRWContextState *draw_ctx = DRW_context_state_get();
607  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
608  if (!sh_data->image) {
609  /* TODO(fclem): Do we want to allow clipping reference images? */
610  sh_data->image = GPU_shader_create_from_info_name(0 ? "overlay_image_clipped" :
611  "overlay_image");
612  }
613  return sh_data->image;
614 }
615 
617 {
618  const DRWContextState *draw_ctx = DRW_context_state_get();
619  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
620  if (!sh_data->motion_path_line) {
622  draw_ctx->sh_cfg ? "overlay_motion_path_line_clipped" : "overlay_motion_path_line");
623  }
624  return sh_data->motion_path_line;
625 }
626 
628 {
629  const DRWContextState *draw_ctx = DRW_context_state_get();
630  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
631  if (!sh_data->motion_path_vert) {
633  draw_ctx->sh_cfg ? "overlay_motion_path_point_clipped" : "overlay_motion_path_point");
634  }
635  return sh_data->motion_path_vert;
636 }
637 
639 {
640  const DRWContextState *draw_ctx = DRW_context_state_get();
641  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
642  if (use_wire && !sh_data->outline_prepass_wire) {
644  draw_ctx->sh_cfg ? "overlay_outline_prepass_wire_clipped" :
645  "overlay_outline_prepass_wire");
646  }
647  else if (!sh_data->outline_prepass) {
649  draw_ctx->sh_cfg ? "overlay_outline_prepass_mesh_clipped" :
650  "overlay_outline_prepass_mesh");
651  }
652  return use_wire ? sh_data->outline_prepass_wire : sh_data->outline_prepass;
653 }
654 
656 {
657  const DRWContextState *draw_ctx = DRW_context_state_get();
658  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
661  draw_ctx->sh_cfg ? "overlay_outline_prepass_curves_clipped" :
662  "overlay_outline_prepass_curves");
663  }
665 }
666 
668 {
669  const DRWContextState *draw_ctx = DRW_context_state_get();
670  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
673  draw_ctx->sh_cfg ? "overlay_outline_prepass_gpencil_clipped" :
674  "overlay_outline_prepass_gpencil");
675  }
677 }
678 
680 {
681  const DRWContextState *draw_ctx = DRW_context_state_get();
682  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
685  draw_ctx->sh_cfg ? "overlay_outline_prepass_pointcloud_clipped" :
686  "overlay_outline_prepass_pointcloud");
687  }
689 }
690 
692 {
693  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
694  if (!sh_data->outline_detect) {
695  sh_data->outline_detect = GPU_shader_create_from_info_name("overlay_outline_detect");
696  }
697  return sh_data->outline_detect;
698 }
699 
701 {
702  const DRWContextState *draw_ctx = DRW_context_state_get();
703  eGPUShaderConfig sh_cfg = draw_ctx->sh_cfg;
704  OVERLAY_Shaders *sh_data = &e_data.sh_data[sh_cfg];
705  if (!sh_data->paint_face) {
707  sh_cfg == GPU_SHADER_CFG_CLIPPED ? "overlay_paint_face_clipped" : "overlay_paint_face");
708  }
709  return sh_data->paint_face;
710 }
711 
713 {
714  const DRWContextState *draw_ctx = DRW_context_state_get();
715  eGPUShaderConfig sh_cfg = draw_ctx->sh_cfg;
716  OVERLAY_Shaders *sh_data = &e_data.sh_data[sh_cfg];
717  if (!sh_data->paint_point) {
719  sh_cfg == GPU_SHADER_CFG_CLIPPED ? "overlay_paint_point_clipped" : "overlay_paint_point");
720  }
721  return sh_data->paint_point;
722 }
723 
725 {
726  const DRWContextState *draw_ctx = DRW_context_state_get();
727  eGPUShaderConfig sh_cfg = draw_ctx->sh_cfg;
728  OVERLAY_Shaders *sh_data = &e_data.sh_data[sh_cfg];
729  if (!sh_data->paint_texture) {
731  sh_cfg ? "overlay_paint_texture_clipped" : "overlay_paint_texture");
732  }
733  return sh_data->paint_texture;
734 }
735 
737 {
738  const DRWContextState *draw_ctx = DRW_context_state_get();
739  eGPUShaderConfig sh_cfg = draw_ctx->sh_cfg;
740  OVERLAY_Shaders *sh_data = &e_data.sh_data[sh_cfg];
741  if (!sh_data->paint_vertcol) {
743  sh_cfg ? "overlay_paint_vertcol_clipped" : "overlay_paint_vertcol");
744  }
745  return sh_data->paint_vertcol;
746 }
747 
749 {
750  const char *info_name[2][2] = {
751  {"overlay_paint_weight", "overlay_paint_weight_fake_shading"},
752  {"overlay_paint_weight_clipped", "overlay_paint_weight_fake_shading_clipped"},
753  };
754  int index = shading ? 1 : 0;
755  const DRWContextState *draw_ctx = DRW_context_state_get();
756  eGPUShaderConfig sh_cfg = draw_ctx->sh_cfg;
757  OVERLAY_Shaders *sh_data = &e_data.sh_data[sh_cfg];
758  if (!sh_data->paint_weight[index]) {
759  sh_data->paint_weight[index] = GPU_shader_create_from_info_name(info_name[sh_cfg][index]);
760  }
761  return sh_data->paint_weight[index];
762 }
763 
765 {
766  const DRWContextState *draw_ctx = DRW_context_state_get();
767  eGPUShaderConfig sh_cfg = draw_ctx->sh_cfg;
768  OVERLAY_Shaders *sh_data = &e_data.sh_data[sh_cfg];
769  if (!sh_data->paint_wire) {
770  sh_data->paint_wire = GPU_shader_create_from_info_name(sh_cfg ? "overlay_paint_wire_clipped" :
771  "overlay_paint_wire");
772  }
773  return sh_data->paint_wire;
774 }
775 
777 {
778  const DRWContextState *draw_ctx = DRW_context_state_get();
779  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
780  if (!sh_data->particle_dot) {
782  draw_ctx->sh_cfg ? "overlay_particle_dot_clipped" : "overlay_particle_dot");
783  }
784  return sh_data->particle_dot;
785 }
786 
788 {
789  const DRWContextState *draw_ctx = DRW_context_state_get();
790  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
791  if (!sh_data->particle_shape) {
793  draw_ctx->sh_cfg ? "overlay_particle_shape_clipped" : "overlay_particle_shape");
794  }
795  return sh_data->particle_shape;
796 }
797 
799 {
800  const DRWContextState *draw_ctx = DRW_context_state_get();
801  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
802  if (!sh_data->sculpt_mask) {
804  draw_ctx->sh_cfg ? "overlay_sculpt_mask_clipped" : "overlay_sculpt_mask");
805  }
806  return sh_data->sculpt_mask;
807 }
808 
810 {
811  const DRWContextState *draw_ctx = DRW_context_state_get();
812  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
815  draw_ctx->sh_cfg == GPU_SHADER_CFG_CLIPPED ? "overlay_sculpt_curves_selection_clipped" :
816  "overlay_sculpt_curves_selection");
817  }
819 }
820 
822 {
823  const DRWContextState *draw_ctx = DRW_context_state_get();
824  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
825  if (!sh_data->uniform_color) {
827  draw_ctx->sh_cfg ? "overlay_uniform_color_clipped" : "overlay_uniform_color");
828  }
829  return sh_data->uniform_color;
830 }
831 
832 struct GPUShader *OVERLAY_shader_volume_velocity(bool use_needle, bool use_mac)
833 {
834  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
835  if (use_needle && !sh_data->volume_velocity_needle_sh) {
837  "overlay_volume_velocity_needle");
838  }
839  else if (use_mac && !sh_data->volume_velocity_mac_sh) {
841  "overlay_volume_velocity_mac");
842  }
843  else if (!sh_data->volume_velocity_sh) {
844  sh_data->volume_velocity_sh = GPU_shader_create_from_info_name("overlay_volume_velocity");
845  }
846 
847  if (use_needle) {
849  }
850  if (use_mac) {
852  }
853  return sh_data->volume_velocity_sh;
854 }
855 
856 struct GPUShader *OVERLAY_shader_volume_gridlines(bool color_with_flags, bool color_range)
857 {
858  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
859  if (!sh_data->volume_gridlines_flags_sh && color_with_flags) {
861  "overlay_volume_gridlines_flags");
862  }
863  else if (!sh_data->volume_gridlines_range_sh && color_range) {
865  "overlay_volume_gridlines_range");
866  }
867  else if (!sh_data->volume_gridlines_sh) {
868  sh_data->volume_gridlines_sh = GPU_shader_create_from_info_name("overlay_volume_gridlines");
869  }
870 
871  if (color_with_flags) {
873  }
874  if (color_range) {
876  }
877 
879 }
880 
882 {
883  const DRWContextState *draw_ctx = DRW_context_state_get();
884  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
885  if (!sh_data->wireframe_select) {
887  draw_ctx->sh_cfg ? "overlay_wireframe_select_clipped" : "overlay_wireframe_select");
888  }
889  return sh_data->wireframe_select;
890 }
891 
893 {
894  const DRWContextState *draw_ctx = DRW_context_state_get();
895  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
896  if (!sh_data->wireframe[custom_bias]) {
898  custom_bias ? (draw_ctx->sh_cfg ? "overlay_wireframe_custom_depth_clipped" :
899  "overlay_wireframe_custom_depth") :
900  (draw_ctx->sh_cfg ? "overlay_wireframe_clipped" : "overlay_wireframe"));
901  }
902  return sh_data->wireframe[custom_bias];
903 }
904 
906 {
907  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
908  if (!sh_data->xray_fade) {
909  sh_data->xray_fade = GPU_shader_create_from_info_name("overlay_xray_fade");
910  }
911  return sh_data->xray_fade;
912 }
913 
914 /* -------------------------------------------------------------------- */
919 {
920  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
921  if (!sh_data->edit_uv_edges) {
922  sh_data->edit_uv_edges = GPU_shader_create_from_info_name("overlay_edit_uv_edges");
923  }
924  return sh_data->edit_uv_edges;
925 }
926 
928 {
929  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
932  "overlay_edit_uv_edges_select");
933  }
935 }
936 
938 {
939  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
940  if (!sh_data->edit_uv_faces) {
941  sh_data->edit_uv_faces = GPU_shader_create_from_info_name("overlay_edit_uv_faces");
942  }
943  return sh_data->edit_uv_faces;
944 }
945 
947 {
948  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
949  if (!sh_data->edit_uv_face_dots) {
950  sh_data->edit_uv_face_dots = GPU_shader_create_from_info_name("overlay_edit_uv_face_dots");
951  }
952  return sh_data->edit_uv_face_dots;
953 }
954 
956 {
957  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
958  if (!sh_data->edit_uv_verts) {
959  sh_data->edit_uv_verts = GPU_shader_create_from_info_name("overlay_edit_uv_verts");
960  }
961 
962  return sh_data->edit_uv_verts;
963 }
964 
966 {
967  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
970  "overlay_edit_uv_stretching_area");
971  }
972 
974 }
975 
977 {
978  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
981  "overlay_edit_uv_stretching_angle");
982  }
983 
985 }
986 
988 {
989  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
992  "overlay_edit_uv_tiled_image_borders");
993  }
995 }
996 
1000 
1002 {
1004  {
1005  {"pos", DRW_ATTR_FLOAT, 3},
1006  });
1008  {
1009  {"pos", DRW_ATTR_FLOAT, 3},
1010  {"color", DRW_ATTR_FLOAT, 4},
1011  });
1013  {
1014  {"inst_pos", DRW_ATTR_FLOAT, 3},
1015  });
1017  {
1018  {"color", DRW_ATTR_FLOAT, 4},
1019  {"inst_obmat", DRW_ATTR_FLOAT, 16},
1020  });
1022  {
1023  {"pos", DRW_ATTR_FLOAT, 3},
1024  {"colorid", DRW_ATTR_INT, 1},
1025  });
1027  {
1028  {"pos", DRW_ATTR_FLOAT, 3},
1029  {"colorid", DRW_ATTR_INT, 1},
1030  });
1032  {
1033  {"inst_obmat", DRW_ATTR_FLOAT, 16},
1034  });
1036  {
1037  {"boneStart", DRW_ATTR_FLOAT, 3},
1038  {"boneEnd", DRW_ATTR_FLOAT, 3},
1039  {"wireColor", DRW_ATTR_FLOAT, 4}, /* TODO: uchar color. */
1040  {"boneColor", DRW_ATTR_FLOAT, 4},
1041  {"headColor", DRW_ATTR_FLOAT, 4},
1042  {"tailColor", DRW_ATTR_FLOAT, 4},
1043  });
1045  {
1046  {"headSphere", DRW_ATTR_FLOAT, 4},
1047  {"tailSphere", DRW_ATTR_FLOAT, 4},
1048  {"outlineColorSize", DRW_ATTR_FLOAT, 4},
1049  {"xAxis", DRW_ATTR_FLOAT, 3},
1050  });
1052  {
1053  {"headSphere", DRW_ATTR_FLOAT, 4},
1054  {"tailSphere", DRW_ATTR_FLOAT, 4},
1055  {"xAxis", DRW_ATTR_FLOAT, 3},
1056  });
1058  {
1059  {"headSphere", DRW_ATTR_FLOAT, 4},
1060  {"tailSphere", DRW_ATTR_FLOAT, 4},
1061  {"boneColor", DRW_ATTR_FLOAT, 3},
1062  {"stateColor", DRW_ATTR_FLOAT, 3},
1063  {"xAxis", DRW_ATTR_FLOAT, 3},
1064  });
1065 
1066  return &g_formats;
1067 }
1068 
1070 {
1071  for (int sh_data_index = 0; sh_data_index < ARRAY_SIZE(e_data.sh_data); sh_data_index++) {
1072  OVERLAY_Shaders *sh_data = &e_data.sh_data[sh_data_index];
1073  GPUShader **sh_data_as_array = (GPUShader **)sh_data;
1074  for (int i = 0; i < (sizeof(OVERLAY_Shaders) / sizeof(GPUShader *)); i++) {
1075  DRW_SHADER_FREE_SAFE(sh_data_as_array[i]);
1076  }
1077  }
1078  struct GPUVertFormat **format = (struct GPUVertFormat **)&g_formats;
1079  for (int i = 0; i < sizeof(g_formats) / sizeof(void *); i++, format++) {
1081  }
1082 }
#define ARRAY_SIZE(arr)
#define DRW_shgroup_instance_format(format,...)
Definition: DRW_render.h:381
#define DRW_SHADER_FREE_SAFE(shader)
Definition: DRW_render.h:254
struct GPUShader GPUShader
Definition: GPU_shader.h:20
eGPUShaderConfig
Definition: GPU_shader.h:364
@ GPU_SHADER_CFG_CLIPPED
Definition: GPU_shader.h:366
GPUShader * GPU_shader_create_from_info_name(const char *info_name)
Definition: gpu_shader.cc:265
#define GPU_SHADER_CFG_LEN
Definition: GPU_shader.h:368
#define MEM_SAFE_FREE(v)
const DRWContextState * DRW_context_state_get(void)
ccl_gpu_kernel_postfix ccl_global float int int int int sh
format
Definition: logImageCore.h:38
GPUShader * OVERLAY_shader_edit_lattice_wire(void)
GPUShader * OVERLAY_shader_edit_uv_stretching_angle_get(void)
GPUShader * OVERLAY_shader_sculpt_curves_selection(void)
GPUShader * OVERLAY_shader_paint_weight(const bool shading)
GPUShader * OVERLAY_shader_image(void)
GPUShader * OVERLAY_shader_edit_curve_handle(void)
void OVERLAY_shader_free(void)
GPUShader * OVERLAY_shader_armature_degrees_of_freedom_wire(void)
GPUShader * OVERLAY_shader_edit_gpencil_guide_point(void)
static struct @266 e_data
GPUShader * OVERLAY_shader_edit_lattice_point(void)
struct OVERLAY_Shaders OVERLAY_Shaders
GPUShader * OVERLAY_shader_edit_mesh_edge(bool use_flat_interp)
GPUShader * OVERLAY_shader_paint_face(void)
GPUShader * OVERLAY_shader_edit_uv_face_get(void)
GPUShader * OVERLAY_shader_armature_sphere(bool use_outline)
GPUShader * OVERLAY_shader_wireframe(bool custom_bias)
GPUShader * OVERLAY_shader_edit_gpencil_point(void)
GPUShader * OVERLAY_shader_edit_curve_wire(void)
GPUShader * OVERLAY_shader_outline_prepass(bool use_wire)
GPUShader * OVERLAY_shader_edit_mesh_facedot(void)
GPUShader * OVERLAY_shader_extra_groundline(void)
GPUShader * OVERLAY_shader_extra_loose_point(void)
GPUShader * OVERLAY_shader_armature_degrees_of_freedom_solid(void)
GPUShader * OVERLAY_shader_edit_uv_stencil_image(void)
OVERLAY_Shaders sh_data[GPU_SHADER_CFG_LEN]
GPUShader * OVERLAY_shader_edit_gpencil_wire(void)
GPUShader * OVERLAY_shader_background(void)
GPUShader * OVERLAY_shader_grid_background(void)
GPUShader * OVERLAY_shader_clipbound(void)
GPUShader * OVERLAY_shader_edit_uv_face_dots_get(void)
struct GPUShader * OVERLAY_shader_volume_velocity(bool use_needle, bool use_mac)
GPUShader * OVERLAY_shader_motion_path_vert(void)
GPUShader * OVERLAY_shader_particle_dot(void)
GPUShader * OVERLAY_shader_paint_point(void)
GPUShader * OVERLAY_shader_edit_mesh_skin_root(void)
GPUShader * OVERLAY_shader_extra_grid(void)
GPUShader * OVERLAY_shader_outline_prepass_curves()
struct GPUShader * OVERLAY_shader_volume_gridlines(bool color_with_flags, bool color_range)
GPUShader * OVERLAY_shader_edit_uv_stretching_area_get(void)
GPUShader * OVERLAY_shader_particle_shape(void)
GPUShader * OVERLAY_shader_motion_path_line(void)
GPUShader * OVERLAY_shader_edit_mesh_vert(void)
GPUShader * OVERLAY_shader_edit_uv_verts_get(void)
GPUShader * OVERLAY_shader_extra(bool is_select)
GPUShader * OVERLAY_shader_edit_particle_strand(void)
GPUShader * OVERLAY_shader_extra_wire(bool use_object, bool is_select)
GPUShader * OVERLAY_shader_sculpt_mask(void)
GPUShader * OVERLAY_shader_edit_uv_mask_image(void)
GPUShader * OVERLAY_shader_armature_shape_wire(void)
GPUShader * OVERLAY_shader_edit_uv_edges_get(void)
GPUShader * OVERLAY_shader_edit_mesh_face(void)
GPUShader * OVERLAY_shader_edit_mesh_normal(void)
GPUShader * OVERLAY_shader_armature_shape(bool use_outline)
GPUShader * OVERLAY_shader_xray_fade(void)
GPUShader * OVERLAY_shader_armature_wire(void)
GPUShader * OVERLAY_shader_grid(void)
GPUShader * OVERLAY_shader_edit_curve_point(void)
GPUShader * OVERLAY_shader_depth_only(void)
GPUShader * OVERLAY_shader_paint_wire(void)
GPUShader * OVERLAY_shader_armature_envelope(bool use_outline)
GPUShader * OVERLAY_shader_edit_particle_point(void)
GPUShader * OVERLAY_shader_edit_uv_tiled_image_borders_get(void)
GPUShader * OVERLAY_shader_paint_vertcol(void)
GPUShader * OVERLAY_shader_edit_uv_edges_for_edge_select_get(void)
GPUShader * OVERLAY_shader_extra_point(void)
GPUShader * OVERLAY_shader_grid_image(void)
GPUShader * OVERLAY_shader_outline_prepass_gpencil(void)
GPUShader * OVERLAY_shader_antialiasing(void)
GPUShader * OVERLAY_shader_outline_prepass_pointcloud(void)
GPUShader * OVERLAY_shader_gpencil_canvas(void)
struct GPUShader * OVERLAY_shader_uniform_color(void)
GPUShader * OVERLAY_shader_outline_detect(void)
GPUShader * OVERLAY_shader_armature_stick(void)
OVERLAY_InstanceFormats * OVERLAY_shader_instance_formats_get(void)
GPUShader * OVERLAY_shader_facing(void)
static OVERLAY_InstanceFormats g_formats
GPUShader * OVERLAY_shader_paint_texture(void)
GPUShader * OVERLAY_shader_edit_mesh_analysis(void)
GPUShader * OVERLAY_shader_wireframe_select(void)
eGPUShaderConfig sh_cfg
Definition: DRW_render.h:993
struct GPUVertFormat * point_extra
struct GPUVertFormat * instance_bone_envelope_outline
struct GPUVertFormat * instance_bone
struct GPUVertFormat * pos
struct GPUVertFormat * pos_color
struct GPUVertFormat * instance_extra
struct GPUVertFormat * wire_extra
struct GPUVertFormat * instance_pos
struct GPUVertFormat * instance_bone_envelope
struct GPUVertFormat * instance_bone_stick
struct GPUVertFormat * instance_bone_envelope_distance
GPUShader * image
GPUShader * edit_curve_handle
GPUShader * edit_uv_stencil_image
GPUShader * edit_mesh_face
GPUShader * edit_uv_face_dots
GPUShader * paint_weight[2]
GPUShader * volume_gridlines_sh
GPUShader * armature_envelope_solid
GPUShader * edit_uv_faces
GPUShader * edit_particle_strand
GPUShader * grid_image
GPUShader * volume_velocity_mac_sh
GPUShader * paint_face
GPUShader * depth_only
GPUShader * clipbound
GPUShader * paint_vertcol
GPUShader * wireframe_select
GPUShader * edit_mesh_normals
GPUShader * grid_background
GPUShader * outline_prepass_pointcloud
GPUShader * edit_uv_verts
GPUShader * edit_uv_stretching_angle
GPUShader * motion_path_vert
GPUShader * outline_detect
GPUShader * grid
GPUShader * edit_mesh_edge_flat
GPUShader * edit_mesh_skin_root
GPUShader * edit_mesh_fnormals
GPUShader * particle_dot
GPUShader * edit_curve_point
GPUShader * armature_shape_solid
GPUShader * volume_gridlines_flags_sh
GPUShader * paint_wire
GPUShader * sculpt_mask
GPUShader * edit_mesh_edge
GPUShader * outline_prepass_gpencil
GPUShader * sculpt_curves_selection
GPUShader * edit_uv_tiled_image_borders
GPUShader * edit_gpencil_guide_point
GPUShader * uniform_color
GPUShader * edit_mesh_facedot
GPUShader * edit_uv_edges
GPUShader * outline_prepass_curves
GPUShader * particle_shape
GPUShader * antialiasing
GPUShader * outline_prepass
GPUShader * armature_sphere_solid
GPUShader * edit_gpencil_wire
GPUShader * armature_shape_wire
GPUShader * edit_lattice_point
GPUShader * extra_point
GPUShader * extra_loose_point
GPUShader * extra_select
GPUShader * edit_lattice_wire
GPUShader * armature_envelope_outline
GPUShader * background
GPUShader * extra_lightprobe_grid
GPUShader * wireframe[2]
GPUShader * paint_texture
GPUShader * edit_mesh_vert
GPUShader * edit_mesh_analysis
GPUShader * extra_groundline
GPUShader * facing
GPUShader * edit_gpencil_point
GPUShader * paint_point
GPUShader * armature_shape_outline
GPUShader * xray_fade
GPUShader * edit_uv_edges_for_edge_select
GPUShader * volume_velocity_needle_sh
GPUShader * extra_wire[2]
GPUShader * armature_stick
GPUShader * outline_prepass_wire
GPUShader * edit_uv_mask_image
GPUShader * pointcloud_dot
GPUShader * armature_dof_wire
GPUShader * armature_wire
GPUShader * edit_particle_point
GPUShader * volume_velocity_sh
GPUShader * edit_mesh_vnormals
GPUShader * edit_curve_wire
GPUShader * extra_wire_select
GPUShader * armature_dof_solid
GPUShader * volume_gridlines_range_sh
GPUShader * gpencil_canvas
GPUShader * edit_uv_stretching_area
GPUShader * armature_sphere_outline
GPUShader * motion_path_line
GPUShader * extra