Blender  V2.93
overlay_shader.c
Go to the documentation of this file.
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  * Copyright 2019, Blender Foundation.
17  */
18 
23 #include "DRW_render.h"
24 
25 #include "GPU_shader.h"
26 
27 #include "UI_resources.h"
28 
29 #include "overlay_private.h"
30 
31 extern char datatoc_antialiasing_frag_glsl[];
32 extern char datatoc_antialiasing_vert_glsl[];
33 extern char datatoc_armature_dof_vert_glsl[];
34 extern char datatoc_armature_dof_solid_frag_glsl[];
35 extern char datatoc_armature_envelope_distance_frag_glsl[];
36 extern char datatoc_armature_envelope_outline_vert_glsl[];
37 extern char datatoc_armature_envelope_solid_frag_glsl[];
38 extern char datatoc_armature_envelope_solid_vert_glsl[];
39 extern char datatoc_armature_shape_outline_geom_glsl[];
40 extern char datatoc_armature_shape_outline_vert_glsl[];
41 extern char datatoc_armature_shape_solid_frag_glsl[];
42 extern char datatoc_armature_shape_solid_vert_glsl[];
43 extern char datatoc_armature_shape_wire_vert_glsl[];
44 extern char datatoc_armature_sphere_outline_vert_glsl[];
45 extern char datatoc_armature_sphere_solid_frag_glsl[];
46 extern char datatoc_armature_sphere_solid_vert_glsl[];
47 extern char datatoc_armature_stick_frag_glsl[];
48 extern char datatoc_armature_stick_vert_glsl[];
49 extern char datatoc_armature_wire_frag_glsl[];
50 extern char datatoc_armature_wire_vert_glsl[];
51 extern char datatoc_background_frag_glsl[];
52 extern char datatoc_clipbound_vert_glsl[];
53 extern char datatoc_depth_only_vert_glsl[];
54 extern char datatoc_edit_curve_handle_geom_glsl[];
55 extern char datatoc_edit_curve_handle_vert_glsl[];
56 extern char datatoc_edit_curve_point_vert_glsl[];
57 extern char datatoc_edit_curve_wire_vert_glsl[];
58 extern char datatoc_edit_gpencil_canvas_vert_glsl[];
59 extern char datatoc_edit_gpencil_guide_vert_glsl[];
60 extern char datatoc_edit_gpencil_vert_glsl[];
61 extern char datatoc_edit_lattice_point_vert_glsl[];
62 extern char datatoc_edit_lattice_wire_vert_glsl[];
63 extern char datatoc_edit_mesh_common_lib_glsl[];
64 extern char datatoc_edit_mesh_frag_glsl[];
65 extern char datatoc_edit_mesh_geom_glsl[];
66 extern char datatoc_edit_mesh_vert_glsl[];
67 extern char datatoc_edit_mesh_normal_vert_glsl[];
68 extern char datatoc_edit_mesh_skin_root_vert_glsl[];
69 extern char datatoc_edit_mesh_analysis_vert_glsl[];
70 extern char datatoc_edit_mesh_analysis_frag_glsl[];
71 extern char datatoc_edit_particle_strand_vert_glsl[];
72 extern char datatoc_edit_particle_point_vert_glsl[];
73 extern char datatoc_edit_uv_verts_vert_glsl[];
74 extern char datatoc_edit_uv_verts_frag_glsl[];
75 extern char datatoc_edit_uv_edges_vert_glsl[];
76 extern char datatoc_edit_uv_edges_geom_glsl[];
77 extern char datatoc_edit_uv_edges_frag_glsl[];
78 extern char datatoc_edit_uv_faces_vert_glsl[];
79 extern char datatoc_edit_uv_face_dots_vert_glsl[];
80 extern char datatoc_edit_uv_stretching_vert_glsl[];
81 extern char datatoc_edit_uv_image_vert_glsl[];
82 extern char datatoc_edit_uv_tiled_image_borders_vert_glsl[];
83 extern char datatoc_extra_frag_glsl[];
84 extern char datatoc_extra_vert_glsl[];
85 extern char datatoc_extra_groundline_vert_glsl[];
86 extern char datatoc_extra_lightprobe_grid_vert_glsl[];
87 extern char datatoc_extra_loose_point_vert_glsl[];
88 extern char datatoc_extra_loose_point_frag_glsl[];
89 extern char datatoc_extra_point_vert_glsl[];
90 extern char datatoc_extra_wire_frag_glsl[];
91 extern char datatoc_extra_wire_vert_glsl[];
92 extern char datatoc_facing_frag_glsl[];
93 extern char datatoc_facing_vert_glsl[];
94 extern char datatoc_grid_frag_glsl[];
95 extern char datatoc_grid_vert_glsl[];
96 extern char datatoc_image_frag_glsl[];
97 extern char datatoc_edit_uv_image_mask_frag_glsl[];
98 extern char datatoc_image_vert_glsl[];
99 extern char datatoc_motion_path_line_vert_glsl[];
100 extern char datatoc_motion_path_line_geom_glsl[];
101 extern char datatoc_motion_path_point_vert_glsl[];
102 extern char datatoc_outline_detect_frag_glsl[];
103 extern char datatoc_outline_prepass_frag_glsl[];
104 extern char datatoc_outline_prepass_geom_glsl[];
105 extern char datatoc_outline_prepass_vert_glsl[];
106 extern char datatoc_paint_face_vert_glsl[];
107 extern char datatoc_paint_point_vert_glsl[];
108 extern char datatoc_paint_texture_frag_glsl[];
109 extern char datatoc_paint_texture_vert_glsl[];
110 extern char datatoc_paint_vertcol_frag_glsl[];
111 extern char datatoc_paint_vertcol_vert_glsl[];
112 extern char datatoc_paint_weight_frag_glsl[];
113 extern char datatoc_paint_weight_vert_glsl[];
114 extern char datatoc_paint_wire_vert_glsl[];
115 extern char datatoc_particle_vert_glsl[];
116 extern char datatoc_particle_frag_glsl[];
117 extern char datatoc_sculpt_mask_vert_glsl[];
118 extern char datatoc_sculpt_mask_frag_glsl[];
119 extern char datatoc_volume_velocity_vert_glsl[];
120 extern char datatoc_volume_gridlines_vert_glsl[];
121 extern char datatoc_wireframe_vert_glsl[];
122 extern char datatoc_wireframe_frag_glsl[];
123 extern char datatoc_xray_fade_frag_glsl[];
124 
125 extern char datatoc_gpu_shader_depth_only_frag_glsl[];
126 extern char datatoc_gpu_shader_point_varying_color_frag_glsl[];
127 extern char datatoc_gpu_shader_3D_smooth_color_frag_glsl[];
128 extern char datatoc_gpu_shader_2D_smooth_color_frag_glsl[];
129 extern char datatoc_gpu_shader_uniform_color_frag_glsl[];
130 extern char datatoc_gpu_shader_flat_color_frag_glsl[];
131 extern char datatoc_gpu_shader_point_varying_color_varying_outline_aa_frag_glsl[];
132 extern char datatoc_gpu_shader_common_obinfos_lib_glsl[];
133 
134 extern char datatoc_gpencil_common_lib_glsl[];
135 
136 extern char datatoc_common_overlay_lib_glsl[];
137 extern char datatoc_common_colormanagement_lib_glsl[];
138 extern char datatoc_common_fullscreen_vert_glsl[];
139 extern char datatoc_common_fxaa_lib_glsl[];
140 extern char datatoc_common_smaa_lib_glsl[];
141 extern char datatoc_common_globals_lib_glsl[];
142 extern char datatoc_common_pointcloud_lib_glsl[];
143 extern char datatoc_common_view_lib_glsl[];
144 
145 typedef struct OVERLAY_Shaders {
146  GPUShader *antialiasing;
147  GPUShader *armature_dof_wire;
148  GPUShader *armature_dof_solid;
149  GPUShader *armature_envelope_outline;
150  GPUShader *armature_envelope_solid;
151  GPUShader *armature_shape_outline;
152  GPUShader *armature_shape_solid;
153  GPUShader *armature_shape_wire;
154  GPUShader *armature_sphere_outline;
155  GPUShader *armature_sphere_solid;
156  GPUShader *armature_stick;
157  GPUShader *armature_wire;
158  GPUShader *background;
159  GPUShader *clipbound;
160  GPUShader *depth_only;
161  GPUShader *edit_curve_handle;
162  GPUShader *edit_curve_point;
163  GPUShader *edit_curve_wire;
164  GPUShader *edit_gpencil_guide_point;
165  GPUShader *edit_gpencil_point;
166  GPUShader *edit_gpencil_wire;
167  GPUShader *edit_lattice_point;
168  GPUShader *edit_lattice_wire;
169  GPUShader *edit_mesh_vert;
170  GPUShader *edit_mesh_edge;
171  GPUShader *edit_mesh_edge_flat;
172  GPUShader *edit_mesh_face;
173  GPUShader *edit_mesh_facedot;
174  GPUShader *edit_mesh_skin_root;
175  GPUShader *edit_mesh_vnormals;
176  GPUShader *edit_mesh_normals;
177  GPUShader *edit_mesh_fnormals;
178  GPUShader *edit_mesh_analysis;
179  GPUShader *edit_particle_strand;
180  GPUShader *edit_particle_point;
181  GPUShader *edit_uv_verts;
182  GPUShader *edit_uv_faces;
183  GPUShader *edit_uv_edges;
184  GPUShader *edit_uv_face_dots;
185  GPUShader *edit_uv_stretching_angle;
186  GPUShader *edit_uv_stretching_area;
187  GPUShader *edit_uv_tiled_image_borders;
188  GPUShader *edit_uv_stencil_image;
189  GPUShader *edit_uv_mask_image;
190  GPUShader *extra;
191  GPUShader *extra_select;
192  GPUShader *extra_groundline;
193  GPUShader *extra_wire[2];
194  GPUShader *extra_wire_select;
195  GPUShader *extra_point;
196  GPUShader *extra_lightprobe_grid;
197  GPUShader *extra_loose_point;
198  GPUShader *facing;
199  GPUShader *gpencil_canvas;
200  GPUShader *grid;
201  GPUShader *grid_image;
202  GPUShader *image;
203  GPUShader *motion_path_line;
204  GPUShader *motion_path_vert;
205  GPUShader *outline_prepass;
206  GPUShader *outline_prepass_gpencil;
207  GPUShader *outline_prepass_pointcloud;
208  GPUShader *outline_prepass_wire;
209  GPUShader *outline_detect;
210  GPUShader *paint_face;
211  GPUShader *paint_point;
212  GPUShader *paint_texture;
213  GPUShader *paint_vertcol;
214  GPUShader *paint_weight;
215  GPUShader *paint_wire;
216  GPUShader *particle_dot;
217  GPUShader *particle_shape;
218  GPUShader *pointcloud_dot;
219  GPUShader *sculpt_mask;
220  GPUShader *uniform_color;
221  GPUShader *volume_velocity_needle_sh;
222  GPUShader *volume_velocity_mac_sh;
223  GPUShader *volume_velocity_sh;
224  GPUShader *volume_gridlines_sh;
225  GPUShader *volume_gridlines_flags_sh;
226  GPUShader *volume_gridlines_range_sh;
227  GPUShader *wireframe_select;
228  GPUShader *wireframe[2];
229  GPUShader *xray_fade;
230 } OVERLAY_Shaders;
231 
232 static struct {
233  OVERLAY_Shaders sh_data[GPU_SHADER_CFG_LEN];
234  DRWShaderLibrary *lib;
235 } e_data = {{{NULL}}};
236 
237 void OVERLAY_shader_library_ensure(void)
238 {
239  if (e_data.lib == NULL) {
240  e_data.lib = DRW_shader_library_create();
241  /* NOTE: These need to be ordered by dependencies. */
242  DRW_SHADER_LIB_ADD(e_data.lib, common_globals_lib);
243  DRW_SHADER_LIB_ADD(e_data.lib, common_overlay_lib);
244  DRW_SHADER_LIB_ADD(e_data.lib, common_colormanagement_lib);
245  DRW_SHADER_LIB_ADD(e_data.lib, common_view_lib);
246  }
247 }
248 
249 GPUShader *OVERLAY_shader_antialiasing(void)
250 {
251  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
252  if (!sh_data->antialiasing) {
253  sh_data->antialiasing = GPU_shader_create_from_arrays({
254  .vert = (const char *[]){datatoc_common_globals_lib_glsl,
255  datatoc_antialiasing_vert_glsl,
256  NULL},
257  .frag = (const char *[]){datatoc_common_globals_lib_glsl,
258  datatoc_antialiasing_frag_glsl,
259  NULL},
260  .defs = (const char *[]){NULL},
261  });
262  }
263  return sh_data->antialiasing;
264 }
265 
266 GPUShader *OVERLAY_shader_background(void)
267 {
268  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
269  if (!sh_data->background) {
270  sh_data->background = GPU_shader_create_from_arrays({
271  .vert = (const char *[]){datatoc_common_fullscreen_vert_glsl, NULL},
272  .frag =
273  (const char *[]){datatoc_common_globals_lib_glsl, datatoc_background_frag_glsl, NULL},
274  });
275  }
276  return sh_data->background;
277 }
278 
279 GPUShader *OVERLAY_shader_clipbound(void)
280 {
281  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
282  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[0];
283  if (!sh_data->clipbound) {
284  sh_data->clipbound = GPU_shader_create_from_arrays({
285  .vert = (const char *[]){datatoc_common_view_lib_glsl, datatoc_clipbound_vert_glsl, NULL},
286  .frag = (const char *[]){datatoc_gpu_shader_uniform_color_frag_glsl, NULL},
287  .defs = (const char *[]){sh_cfg->def, NULL},
288  });
289  }
290  return sh_data->clipbound;
291 }
292 
293 GPUShader *OVERLAY_shader_depth_only(void)
294 {
295  const DRWContextState *draw_ctx = DRW_context_state_get();
296  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
297  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
298  if (!sh_data->depth_only) {
299  sh_data->depth_only = GPU_shader_create_from_arrays({
300  .vert = (const char *[]){sh_cfg->lib,
301  datatoc_common_view_lib_glsl,
302  datatoc_depth_only_vert_glsl,
303  NULL},
304  .frag = (const char *[]){datatoc_gpu_shader_depth_only_frag_glsl, NULL},
305  .defs = (const char *[]){sh_cfg->def, NULL},
306  });
307  }
308  return sh_data->depth_only;
309 }
310 
311 GPUShader *OVERLAY_shader_edit_mesh_vert(void)
312 {
313  const DRWContextState *draw_ctx = DRW_context_state_get();
314  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
315  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
316  if (!sh_data->edit_mesh_vert) {
317  sh_data->edit_mesh_vert = GPU_shader_create_from_arrays({
318  .vert = (const char *[]){sh_cfg->lib,
319  datatoc_common_globals_lib_glsl,
320  datatoc_common_view_lib_glsl,
321  datatoc_edit_mesh_common_lib_glsl,
322  datatoc_edit_mesh_vert_glsl,
323  NULL},
324  .frag = (const char *[]){datatoc_gpu_shader_point_varying_color_frag_glsl, NULL},
325  .defs = (const char *[]){sh_cfg->def, "#define VERT\n", NULL},
326  });
327  }
328  return sh_data->edit_mesh_vert;
329 }
330 
331 GPUShader *OVERLAY_shader_edit_mesh_edge(bool use_flat_interp)
332 {
333  const DRWContextState *draw_ctx = DRW_context_state_get();
334  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
335  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
336  GPUShader **sh = use_flat_interp ? &sh_data->edit_mesh_edge_flat : &sh_data->edit_mesh_edge;
337  if (*sh == NULL) {
338  /* Use geometry shader to draw edge wire-frame. This ensure us
339  * the same result across platforms and more flexibility.
340  * But we pay the cost of running a geometry shader.
341  * In the future we might consider using only the vertex shader
342  * and loading data manually with buffer textures. */
343  const bool use_geom_shader = true;
344  const bool use_smooth_wires = (U.gpu_flag & USER_GPU_FLAG_NO_EDIT_MODE_SMOOTH_WIRE) == 0;
345  const char *geom_sh_code[] = {use_geom_shader ? sh_cfg->lib : NULL,
346  datatoc_common_globals_lib_glsl,
347  datatoc_common_view_lib_glsl,
348  datatoc_edit_mesh_geom_glsl,
349  NULL};
350  const char *vert_sh_code[] = {sh_cfg->lib,
351  datatoc_common_globals_lib_glsl,
352  datatoc_common_view_lib_glsl,
353  datatoc_edit_mesh_common_lib_glsl,
354  datatoc_edit_mesh_vert_glsl,
355  NULL};
356  const char *frag_sh_code[] = {sh_cfg->lib,
357  datatoc_common_globals_lib_glsl,
358  datatoc_common_view_lib_glsl,
359  datatoc_edit_mesh_common_lib_glsl,
360  datatoc_edit_mesh_frag_glsl,
361  NULL};
362  const char *defs[] = {sh_cfg->def,
363  use_geom_shader ? "#define USE_GEOM_SHADER\n" : "",
364  use_smooth_wires ? "#define USE_SMOOTH_WIRE\n" : "",
365  use_flat_interp ? "#define FLAT\n" : "",
366  "#define EDGE\n",
367  NULL};
368 
369  *sh = GPU_shader_create_from_arrays({
370  .vert = vert_sh_code,
371  .frag = frag_sh_code,
372  .geom = geom_sh_code,
373  .defs = defs,
374  });
375  }
376  return *sh;
377 }
378 
379 GPUShader *OVERLAY_shader_armature_sphere(bool use_outline)
380 {
381  const DRWContextState *draw_ctx = DRW_context_state_get();
382  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
383  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
384  const char extensions[] = "#extension GL_ARB_conservative_depth : enable\n";
385  if (use_outline && !sh_data->armature_sphere_outline) {
386  sh_data->armature_sphere_outline = GPU_shader_create_from_arrays({
387  .vert = (const char *[]){sh_cfg->lib,
388  datatoc_common_globals_lib_glsl,
389  datatoc_common_view_lib_glsl,
390  datatoc_armature_sphere_outline_vert_glsl,
391  NULL},
392  .frag = (const char *[]){extensions,
393  datatoc_common_view_lib_glsl,
394  datatoc_armature_wire_frag_glsl,
395  NULL},
396  .defs = (const char *[]){sh_cfg->def, NULL},
397  });
398  }
399  else if (!sh_data->armature_sphere_solid) {
400  sh_data->armature_sphere_solid = GPU_shader_create_from_arrays({
401  .vert = (const char *[]){sh_cfg->lib,
402  datatoc_common_view_lib_glsl,
403  datatoc_armature_sphere_solid_vert_glsl,
404  NULL},
405  .frag = (const char *[]){extensions,
406  datatoc_common_view_lib_glsl,
407  datatoc_armature_sphere_solid_frag_glsl,
408  NULL},
409  .defs = (const char *[]){sh_cfg->def, NULL},
410  });
411  }
412  return use_outline ? sh_data->armature_sphere_outline : sh_data->armature_sphere_solid;
413 }
414 
415 GPUShader *OVERLAY_shader_armature_shape(bool use_outline)
416 {
417  const DRWContextState *draw_ctx = DRW_context_state_get();
418  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
419  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
420  if (use_outline && !sh_data->armature_shape_outline) {
421  sh_data->armature_shape_outline = GPU_shader_create_from_arrays({
422  .vert = (const char *[]){sh_cfg->lib,
423  datatoc_common_globals_lib_glsl,
424  datatoc_common_view_lib_glsl,
425  datatoc_armature_shape_outline_vert_glsl,
426  NULL},
427  .geom = (const char *[]){sh_cfg->lib,
428  datatoc_common_globals_lib_glsl,
429  datatoc_common_view_lib_glsl,
430  datatoc_armature_shape_outline_geom_glsl,
431  NULL},
432  .frag =
433  (const char *[]){datatoc_common_view_lib_glsl, datatoc_armature_wire_frag_glsl, NULL},
434  .defs = (const char *[]){sh_cfg->def, NULL},
435  });
436  }
437  else if (!sh_data->armature_shape_solid) {
438  sh_data->armature_shape_solid = GPU_shader_create_from_arrays({
439  .vert = (const char *[]){sh_cfg->lib,
440  datatoc_common_view_lib_glsl,
441  datatoc_armature_shape_solid_vert_glsl,
442  NULL},
443  .frag = (const char *[]){datatoc_armature_shape_solid_frag_glsl, NULL},
444  .defs = (const char *[]){sh_cfg->def, NULL},
445  });
446  }
447  return use_outline ? sh_data->armature_shape_outline : sh_data->armature_shape_solid;
448 }
449 
450 GPUShader *OVERLAY_shader_armature_shape_wire(void)
451 {
452  const DRWContextState *draw_ctx = DRW_context_state_get();
453  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
454  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
455  if (!sh_data->armature_shape_wire) {
456  sh_data->armature_shape_wire = GPU_shader_create_from_arrays({
457  .vert = (const char *[]){sh_cfg->lib,
458  datatoc_common_globals_lib_glsl,
459  datatoc_common_view_lib_glsl,
460  datatoc_armature_shape_wire_vert_glsl,
461  NULL},
462  .frag =
463  (const char *[]){datatoc_common_view_lib_glsl, datatoc_armature_wire_frag_glsl, NULL},
464  .defs = (const char *[]){sh_cfg->def, NULL},
465  });
466  }
467  return sh_data->armature_shape_wire;
468 }
469 
470 GPUShader *OVERLAY_shader_armature_envelope(bool use_outline)
471 {
472  const DRWContextState *draw_ctx = DRW_context_state_get();
473  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
474  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
475  if (use_outline && !sh_data->armature_envelope_outline) {
476  sh_data->armature_envelope_outline = GPU_shader_create_from_arrays({
477  .vert = (const char *[]){sh_cfg->lib,
478  datatoc_common_globals_lib_glsl,
479  datatoc_common_view_lib_glsl,
480  datatoc_armature_envelope_outline_vert_glsl,
481  NULL},
482  .frag =
483  (const char *[]){datatoc_common_view_lib_glsl, datatoc_armature_wire_frag_glsl, NULL},
484  .defs = (const char *[]){sh_cfg->def, NULL},
485  });
486  }
487  else if (!sh_data->armature_envelope_solid) {
488  sh_data->armature_envelope_solid = GPU_shader_create_from_arrays({
489  .vert = (const char *[]){sh_cfg->lib,
490  datatoc_common_view_lib_glsl,
491  datatoc_armature_envelope_solid_vert_glsl,
492  NULL},
493  .frag = (const char *[]){datatoc_armature_envelope_solid_frag_glsl, NULL},
494  .defs = (const char *[]){sh_cfg->def, NULL},
495  });
496  }
497  return use_outline ? sh_data->armature_envelope_outline : sh_data->armature_envelope_solid;
498 }
499 
500 GPUShader *OVERLAY_shader_armature_stick(void)
501 {
502  const DRWContextState *draw_ctx = DRW_context_state_get();
503  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
504  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
505  if (!sh_data->armature_stick) {
506  sh_data->armature_stick = GPU_shader_create_from_arrays({
507  .vert = (const char *[]){sh_cfg->lib,
508  datatoc_common_globals_lib_glsl,
509  datatoc_common_view_lib_glsl,
510  datatoc_armature_stick_vert_glsl,
511  NULL},
512  .frag = (const char *[]){datatoc_armature_stick_frag_glsl, NULL},
513  .defs = (const char *[]){sh_cfg->def, NULL},
514  });
515  }
516  return sh_data->armature_stick;
517 }
518 
519 GPUShader *OVERLAY_shader_armature_degrees_of_freedom_wire(void)
520 {
521  const DRWContextState *draw_ctx = DRW_context_state_get();
522  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
523  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
524  if (!sh_data->armature_dof_wire) {
525  sh_data->armature_dof_wire = GPU_shader_create_from_arrays({
526  .vert = (const char *[]){sh_cfg->lib,
527  datatoc_common_globals_lib_glsl,
528  datatoc_common_view_lib_glsl,
529  datatoc_armature_dof_vert_glsl,
530  NULL},
531  .frag =
532  (const char *[]){datatoc_common_view_lib_glsl, datatoc_armature_wire_frag_glsl, NULL},
533  .defs = (const char *[]){sh_cfg->def, "#define EDGE\n", NULL},
534  });
535  }
536  return sh_data->armature_dof_wire;
537 }
538 
539 GPUShader *OVERLAY_shader_armature_degrees_of_freedom_solid(void)
540 {
541  const DRWContextState *draw_ctx = DRW_context_state_get();
542  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
543  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
544  if (!sh_data->armature_dof_solid) {
545  sh_data->armature_dof_solid = GPU_shader_create_from_arrays({
546  .vert = (const char *[]){sh_cfg->lib,
547  datatoc_common_globals_lib_glsl,
548  datatoc_common_view_lib_glsl,
549  datatoc_armature_dof_vert_glsl,
550  NULL},
551  .frag = (const char *[]){datatoc_common_view_lib_glsl,
552  datatoc_armature_dof_solid_frag_glsl,
553  NULL},
554  .defs = (const char *[]){sh_cfg->def, NULL},
555  });
556  }
557  return sh_data->armature_dof_solid;
558 }
559 
560 GPUShader *OVERLAY_shader_armature_wire(void)
561 {
562  const DRWContextState *draw_ctx = DRW_context_state_get();
563  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
564  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
565  if (!sh_data->armature_wire) {
566  sh_data->armature_wire = GPU_shader_create_from_arrays({
567  .vert = (const char *[]){sh_cfg->lib,
568  datatoc_common_globals_lib_glsl,
569  datatoc_common_view_lib_glsl,
570  datatoc_armature_wire_vert_glsl,
571  NULL},
572  .frag =
573  (const char *[]){datatoc_common_view_lib_glsl, datatoc_armature_wire_frag_glsl, NULL},
574  .defs = (const char *[]){sh_cfg->def, NULL},
575  });
576  }
577  return sh_data->armature_wire;
578 }
579 
580 GPUShader *OVERLAY_shader_edit_curve_handle(void)
581 {
582  const DRWContextState *draw_ctx = DRW_context_state_get();
583  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
584  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
585  if (!sh_data->edit_curve_handle) {
586  sh_data->edit_curve_handle = GPU_shader_create_from_arrays({
587  .vert = (const char *[]){sh_cfg->lib,
588  datatoc_common_globals_lib_glsl,
589  datatoc_common_view_lib_glsl,
590  datatoc_edit_curve_handle_vert_glsl,
591  NULL},
592  .geom = (const char *[]){sh_cfg->lib,
593  datatoc_common_globals_lib_glsl,
594  datatoc_common_view_lib_glsl,
595  datatoc_edit_curve_handle_geom_glsl,
596  NULL},
597  .frag = (const char *[]){datatoc_gpu_shader_3D_smooth_color_frag_glsl, NULL},
598  .defs = (const char *[]){sh_cfg->def, NULL},
599  });
600  }
601  return sh_data->edit_curve_handle;
602 }
603 
604 GPUShader *OVERLAY_shader_edit_curve_point(void)
605 {
606  const DRWContextState *draw_ctx = DRW_context_state_get();
607  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
608  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
609  if (!sh_data->edit_curve_point) {
610  sh_data->edit_curve_point = GPU_shader_create_from_arrays({
611  .vert = (const char *[]){sh_cfg->lib,
612  datatoc_common_globals_lib_glsl,
613  datatoc_common_view_lib_glsl,
614  datatoc_edit_curve_point_vert_glsl,
615  NULL},
616  .frag = (const char *[]){datatoc_gpu_shader_point_varying_color_frag_glsl, NULL},
617  .defs = (const char *[]){sh_cfg->def, NULL},
618  });
619  }
620  return sh_data->edit_curve_point;
621 }
622 
623 GPUShader *OVERLAY_shader_edit_curve_wire(void)
624 {
625  const DRWContextState *draw_ctx = DRW_context_state_get();
626  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
627  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
628  if (!sh_data->edit_curve_wire) {
629  sh_data->edit_curve_wire = GPU_shader_create_from_arrays({
630  .vert = (const char *[]){sh_cfg->lib,
631  datatoc_common_globals_lib_glsl,
632  datatoc_common_view_lib_glsl,
633  datatoc_edit_curve_wire_vert_glsl,
634  NULL},
635  .frag = (const char *[]){datatoc_gpu_shader_flat_color_frag_glsl, NULL},
636  .defs = (const char *[]){sh_cfg->def, "#define IN_PLACE_INSTANCES\n", NULL},
637  });
638  }
639  return sh_data->edit_curve_wire;
640 }
641 
642 GPUShader *OVERLAY_shader_edit_gpencil_guide_point(void)
643 {
644  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
645  if (!sh_data->edit_gpencil_guide_point) {
646  sh_data->edit_gpencil_guide_point = GPU_shader_create_from_arrays({
647  .vert = (const char *[]){datatoc_common_view_lib_glsl,
648  datatoc_edit_gpencil_guide_vert_glsl,
649  NULL},
650  .frag = (const char *[]){datatoc_gpu_shader_point_varying_color_frag_glsl, NULL},
651  });
652  }
653  return sh_data->edit_gpencil_guide_point;
654 }
655 
656 GPUShader *OVERLAY_shader_edit_gpencil_point(void)
657 {
658  const DRWContextState *draw_ctx = DRW_context_state_get();
659  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
660  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
661  if (!sh_data->edit_gpencil_point) {
662  sh_data->edit_gpencil_point = GPU_shader_create_from_arrays({
663  .vert = (const char *[]){sh_cfg->lib,
664  datatoc_common_globals_lib_glsl,
665  datatoc_common_view_lib_glsl,
666  datatoc_edit_gpencil_vert_glsl,
667  NULL},
668  .frag = (const char *[]){datatoc_gpu_shader_point_varying_color_frag_glsl, NULL},
669  .defs = (const char *[]){sh_cfg->def, "#define USE_POINTS\n", NULL},
670  });
671  }
672  return sh_data->edit_gpencil_point;
673 }
674 
675 GPUShader *OVERLAY_shader_edit_gpencil_wire(void)
676 {
677  const DRWContextState *draw_ctx = DRW_context_state_get();
678  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
679  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
680  if (!sh_data->edit_gpencil_wire) {
681  sh_data->edit_gpencil_wire = GPU_shader_create_from_arrays({
682  .vert = (const char *[]){sh_cfg->lib,
683  datatoc_common_globals_lib_glsl,
684  datatoc_common_view_lib_glsl,
685  datatoc_edit_gpencil_vert_glsl,
686  NULL},
687  .frag = (const char *[]){datatoc_gpu_shader_3D_smooth_color_frag_glsl, NULL},
688  .defs = (const char *[]){sh_cfg->def, NULL},
689  });
690  }
691  return sh_data->edit_gpencil_wire;
692 }
693 
694 GPUShader *OVERLAY_shader_edit_lattice_point(void)
695 {
696  const DRWContextState *draw_ctx = DRW_context_state_get();
697  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
698  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
699  if (!sh_data->edit_lattice_point) {
700  sh_data->edit_lattice_point = GPU_shader_create_from_arrays({
701  .vert = (const char *[]){sh_cfg->lib,
702  datatoc_common_globals_lib_glsl,
703  datatoc_common_view_lib_glsl,
704  datatoc_edit_lattice_point_vert_glsl,
705  NULL},
706  .frag = (const char *[]){datatoc_gpu_shader_point_varying_color_frag_glsl, NULL},
707  .defs = (const char *[]){sh_cfg->def, NULL},
708  });
709  }
710  return sh_data->edit_lattice_point;
711 }
712 
713 GPUShader *OVERLAY_shader_edit_lattice_wire(void)
714 {
715  const DRWContextState *draw_ctx = DRW_context_state_get();
716  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
717  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
718  if (!sh_data->edit_lattice_wire) {
719  sh_data->edit_lattice_wire = GPU_shader_create_from_arrays({
720  .vert = (const char *[]){sh_cfg->lib,
721  datatoc_common_globals_lib_glsl,
722  datatoc_common_view_lib_glsl,
723  datatoc_edit_lattice_wire_vert_glsl,
724  NULL},
725  .frag = (const char *[]){datatoc_gpu_shader_3D_smooth_color_frag_glsl, NULL},
726  .defs = (const char *[]){sh_cfg->def, NULL},
727  });
728  }
729  return sh_data->edit_lattice_wire;
730 }
731 
732 GPUShader *OVERLAY_shader_edit_mesh_face(void)
733 {
734  const DRWContextState *draw_ctx = DRW_context_state_get();
735  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
736  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
737  if (!sh_data->edit_mesh_face) {
738  sh_data->edit_mesh_face = GPU_shader_create_from_arrays({
739  .vert = (const char *[]){sh_cfg->lib,
740  datatoc_common_globals_lib_glsl,
741  datatoc_common_view_lib_glsl,
742  datatoc_edit_mesh_common_lib_glsl,
743  datatoc_edit_mesh_vert_glsl,
744  NULL},
745  .frag = (const char *[]){datatoc_gpu_shader_3D_smooth_color_frag_glsl, NULL},
746  .defs = (const char *[]){sh_cfg->def, "#define FACE\n", NULL},
747  });
748  }
749  return sh_data->edit_mesh_face;
750 }
751 
752 GPUShader *OVERLAY_shader_edit_mesh_facedot(void)
753 {
754  const DRWContextState *draw_ctx = DRW_context_state_get();
755  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
756  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
757  if (!sh_data->edit_mesh_facedot) {
758  sh_data->edit_mesh_facedot = GPU_shader_create_from_arrays({
759  .vert = (const char *[]){sh_cfg->lib,
760  datatoc_common_globals_lib_glsl,
761  datatoc_common_view_lib_glsl,
762  datatoc_edit_mesh_common_lib_glsl,
763  datatoc_edit_mesh_vert_glsl,
764  NULL},
765  .frag = (const char *[]){datatoc_gpu_shader_point_varying_color_frag_glsl, NULL},
766  .defs = (const char *[]){sh_cfg->def, "#define FACEDOT\n", NULL},
767  });
768  }
769  return sh_data->edit_mesh_facedot;
770 }
771 
772 GPUShader *OVERLAY_shader_edit_mesh_normal(void)
773 {
774  const DRWContextState *draw_ctx = DRW_context_state_get();
775  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
776  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
777  if (!sh_data->edit_mesh_normals) {
778  sh_data->edit_mesh_normals = GPU_shader_create_from_arrays({
779  .vert = (const char *[]){sh_cfg->lib,
780  datatoc_common_globals_lib_glsl,
781  datatoc_common_view_lib_glsl,
782  datatoc_edit_mesh_normal_vert_glsl,
783  NULL},
784  .frag = (const char *[]){datatoc_gpu_shader_flat_color_frag_glsl, NULL},
785  .defs = (const char *[]){sh_cfg->def, "#define INSTANCED_ATTR\n", NULL},
786  });
787  }
788  return sh_data->edit_mesh_normals;
789 }
790 
791 GPUShader *OVERLAY_shader_edit_mesh_analysis(void)
792 {
793  const DRWContextState *draw_ctx = DRW_context_state_get();
794  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
795  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
796  if (!sh_data->edit_mesh_analysis) {
797  sh_data->edit_mesh_analysis = GPU_shader_create_from_arrays({
798  .vert = (const char *[]){sh_cfg->lib,
799  datatoc_common_view_lib_glsl,
800  datatoc_edit_mesh_analysis_vert_glsl,
801  NULL},
802  .frag = (const char *[]){datatoc_edit_mesh_analysis_frag_glsl, NULL},
803  .defs = (const char *[]){sh_cfg->def, NULL},
804  });
805  }
806  return sh_data->edit_mesh_analysis;
807 }
808 
809 GPUShader *OVERLAY_shader_edit_mesh_skin_root(void)
810 {
811  const DRWContextState *draw_ctx = DRW_context_state_get();
812  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
813  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
814  if (!sh_data->edit_mesh_skin_root) {
815  sh_data->edit_mesh_skin_root = GPU_shader_create_from_arrays({
816  .vert = (const char *[]){sh_cfg->lib,
817  datatoc_common_globals_lib_glsl,
818  datatoc_common_view_lib_glsl,
819  datatoc_edit_mesh_skin_root_vert_glsl,
820  NULL},
821  .frag = (const char *[]){datatoc_gpu_shader_flat_color_frag_glsl, NULL},
822  .defs = (const char *[]){sh_cfg->def, "#define INSTANCED_ATTR\n", NULL},
823  });
824  }
825  return sh_data->edit_mesh_skin_root;
826 }
827 
828 GPUShader *OVERLAY_shader_edit_particle_strand(void)
829 {
830  const DRWContextState *draw_ctx = DRW_context_state_get();
831  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
832  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
833  if (!sh_data->edit_particle_strand) {
834  sh_data->edit_particle_strand = GPU_shader_create_from_arrays({
835  .vert = (const char *[]){sh_cfg->lib,
836  datatoc_common_globals_lib_glsl,
837  datatoc_common_view_lib_glsl,
838  datatoc_edit_particle_strand_vert_glsl,
839  NULL},
840  .frag = (const char *[]){datatoc_gpu_shader_3D_smooth_color_frag_glsl, NULL},
841  .defs = (const char *[]){sh_cfg->def, NULL},
842  });
843  }
844  return sh_data->edit_particle_strand;
845 }
846 
847 GPUShader *OVERLAY_shader_edit_particle_point(void)
848 {
849  const DRWContextState *draw_ctx = DRW_context_state_get();
850  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
851  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
852  if (!sh_data->edit_particle_point) {
853  sh_data->edit_particle_point = GPU_shader_create_from_arrays({
854  .vert = (const char *[]){sh_cfg->lib,
855  datatoc_common_globals_lib_glsl,
856  datatoc_common_view_lib_glsl,
857  datatoc_edit_particle_point_vert_glsl,
858  NULL},
859  .frag = (const char *[]){datatoc_gpu_shader_point_varying_color_frag_glsl, NULL},
860  .defs = (const char *[]){sh_cfg->def, NULL},
861  });
862  }
863  return sh_data->edit_particle_point;
864 }
865 
866 GPUShader *OVERLAY_shader_extra(bool is_select)
867 {
868  const DRWContextState *draw_ctx = DRW_context_state_get();
869  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
870  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
871  GPUShader **sh = (is_select) ? &sh_data->extra_select : &sh_data->extra;
872  if (!*sh) {
873  *sh = GPU_shader_create_from_arrays({
874  .vert = (const char *[]){sh_cfg->lib,
875  datatoc_common_globals_lib_glsl,
876  datatoc_common_view_lib_glsl,
877  datatoc_extra_vert_glsl,
878  NULL},
879  .frag = (const char *[]){datatoc_common_view_lib_glsl, datatoc_extra_frag_glsl, NULL},
880  .defs = (const char *[]){sh_cfg->def, (is_select) ? "#define SELECT_EDGES\n" : NULL, NULL},
881  });
882  }
883  return *sh;
884 }
885 
886 GPUShader *OVERLAY_shader_extra_grid(void)
887 {
888  const DRWContextState *draw_ctx = DRW_context_state_get();
889  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
890  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
891  if (!sh_data->extra_lightprobe_grid) {
892  sh_data->extra_lightprobe_grid = GPU_shader_create_from_arrays({
893  .vert = (const char *[]){sh_cfg->lib,
894  datatoc_common_view_lib_glsl,
895  datatoc_common_globals_lib_glsl,
896  datatoc_gpu_shader_common_obinfos_lib_glsl,
897  datatoc_extra_lightprobe_grid_vert_glsl,
898  NULL},
899  .frag = (const char *[]){datatoc_gpu_shader_point_varying_color_frag_glsl, NULL},
900  .defs = (const char *[]){sh_cfg->def, NULL},
901  });
902  }
903  return sh_data->extra_lightprobe_grid;
904 }
905 
906 GPUShader *OVERLAY_shader_extra_groundline(void)
907 {
908  const DRWContextState *draw_ctx = DRW_context_state_get();
909  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
910  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
911  if (!sh_data->extra_groundline) {
912  sh_data->extra_groundline = GPU_shader_create_from_arrays({
913  .vert = (const char *[]){sh_cfg->lib,
914  datatoc_common_globals_lib_glsl,
915  datatoc_common_view_lib_glsl,
916  datatoc_extra_groundline_vert_glsl,
917  NULL},
918  .frag = (const char *[]){datatoc_common_view_lib_glsl, datatoc_extra_frag_glsl, NULL},
919  .defs = (const char *[]){sh_cfg->def, NULL},
920  });
921  }
922  return sh_data->extra_groundline;
923 }
924 
925 GPUShader *OVERLAY_shader_extra_wire(bool use_object, bool is_select)
926 {
927  const DRWContextState *draw_ctx = DRW_context_state_get();
928  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
929  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
930  GPUShader **sh = (is_select) ? &sh_data->extra_wire_select : &sh_data->extra_wire[use_object];
931  if (!*sh) {
932  char colorids[1024];
933  /* NOTE: define all ids we need here. */
934  BLI_snprintf(colorids,
935  sizeof(colorids),
936  "#define TH_ACTIVE %d\n"
937  "#define TH_SELECT %d\n"
938  "#define TH_TRANSFORM %d\n"
939  "#define TH_WIRE %d\n"
940  "#define TH_CAMERA_PATH %d\n",
941  TH_ACTIVE,
942  TH_SELECT,
943  TH_TRANSFORM,
944  TH_WIRE,
945  TH_CAMERA_PATH);
946  *sh = GPU_shader_create_from_arrays({
947  .vert = (const char *[]){sh_cfg->lib,
948  datatoc_common_globals_lib_glsl,
949  datatoc_common_view_lib_glsl,
950  datatoc_extra_wire_vert_glsl,
951  NULL},
952  .frag = (const char *[]){datatoc_common_view_lib_glsl, datatoc_extra_wire_frag_glsl, NULL},
953  .defs = (const char *[]){sh_cfg->def,
954  colorids,
955  (is_select) ? "#define SELECT_EDGES\n" : "",
956  (use_object) ? "#define OBJECT_WIRE \n" : NULL,
957  NULL},
958  });
959  }
960  return *sh;
961 }
962 
963 GPUShader *OVERLAY_shader_extra_loose_point(void)
964 {
965  const DRWContextState *draw_ctx = DRW_context_state_get();
966  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
967  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
968  if (!sh_data->extra_loose_point) {
969  sh_data->extra_loose_point = GPU_shader_create_from_arrays({
970  .vert = (const char *[]){sh_cfg->lib,
971  datatoc_common_globals_lib_glsl,
972  datatoc_common_view_lib_glsl,
973  datatoc_extra_loose_point_vert_glsl,
974  NULL},
975  .frag = (const char *[]){datatoc_common_globals_lib_glsl,
976  datatoc_extra_loose_point_frag_glsl,
977  NULL},
978  .defs = (const char *[]){sh_cfg->def, NULL},
979  });
980  }
981  return sh_data->extra_loose_point;
982 }
983 
984 GPUShader *OVERLAY_shader_extra_point(void)
985 {
986  const DRWContextState *draw_ctx = DRW_context_state_get();
987  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
988  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
989  if (!sh_data->extra_point) {
990  sh_data->extra_point = GPU_shader_create_from_arrays({
991  .vert = (const char *[]){sh_cfg->lib,
992  datatoc_common_globals_lib_glsl,
993  datatoc_common_view_lib_glsl,
994  datatoc_extra_point_vert_glsl,
995  NULL},
996  .frag =
997  (const char *[]){datatoc_gpu_shader_point_varying_color_varying_outline_aa_frag_glsl,
998  NULL},
999  .defs = (const char *[]){sh_cfg->def, NULL},
1000  });
1001  }
1002  return sh_data->extra_point;
1003 }
1004 
1005 GPUShader *OVERLAY_shader_facing(void)
1006 {
1007  const DRWContextState *draw_ctx = DRW_context_state_get();
1008  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1009  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1010  if (!sh_data->facing) {
1011  sh_data->facing = GPU_shader_create_from_arrays({
1012  .vert = (const char *[]){sh_cfg->lib,
1013  datatoc_common_view_lib_glsl,
1014  datatoc_facing_vert_glsl,
1015  NULL},
1016  .frag = (const char *[]){datatoc_common_globals_lib_glsl, datatoc_facing_frag_glsl, NULL},
1017  .defs = (const char *[]){sh_cfg->def, NULL},
1018  });
1019  }
1020  return sh_data->facing;
1021 }
1022 
1023 GPUShader *OVERLAY_shader_gpencil_canvas(void)
1024 {
1025  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
1026  if (!sh_data->gpencil_canvas) {
1027  sh_data->gpencil_canvas = GPU_shader_create_from_arrays({
1028  .vert = (const char *[]){datatoc_common_globals_lib_glsl,
1029  datatoc_common_view_lib_glsl,
1030  datatoc_edit_gpencil_canvas_vert_glsl,
1031  NULL},
1032  .frag = (const char *[]){datatoc_common_view_lib_glsl, datatoc_extra_frag_glsl, NULL},
1033  });
1034  }
1035  return sh_data->gpencil_canvas;
1036 }
1037 
1038 GPUShader *OVERLAY_shader_grid(void)
1039 {
1040  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
1041  if (!sh_data->grid) {
1042  sh_data->grid = GPU_shader_create_from_arrays({
1043  .vert = (const char *[]){datatoc_common_globals_lib_glsl,
1044  datatoc_common_view_lib_glsl,
1045  datatoc_grid_vert_glsl,
1046  NULL},
1047  .frag = (const char *[]){datatoc_common_globals_lib_glsl,
1048  datatoc_common_view_lib_glsl,
1049  datatoc_grid_frag_glsl,
1050  NULL},
1051  });
1052  }
1053  return sh_data->grid;
1054 }
1055 
1056 GPUShader *OVERLAY_shader_grid_image(void)
1057 {
1058  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
1059  if (!sh_data->grid_image) {
1060  sh_data->grid_image = DRW_shader_create_with_shaderlib(
1061  datatoc_edit_uv_tiled_image_borders_vert_glsl,
1062  NULL,
1063  datatoc_gpu_shader_uniform_color_frag_glsl,
1064  e_data.lib,
1065  "#define blender_srgb_to_framebuffer_space(a) a\n");
1066  }
1067  return sh_data->grid_image;
1068 }
1069 
1070 GPUShader *OVERLAY_shader_edit_uv_stencil_image(void)
1071 {
1072  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
1073  if (!sh_data->edit_uv_stencil_image) {
1074  sh_data->edit_uv_stencil_image = DRW_shader_create_with_shaderlib(
1075  datatoc_edit_uv_image_vert_glsl, NULL, datatoc_image_frag_glsl, e_data.lib, NULL);
1076  }
1077  return sh_data->edit_uv_stencil_image;
1078 }
1079 
1080 GPUShader *OVERLAY_shader_edit_uv_mask_image(void)
1081 {
1082  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
1083  if (!sh_data->edit_uv_mask_image) {
1084  sh_data->edit_uv_mask_image = DRW_shader_create_with_shaderlib(
1085  datatoc_edit_uv_image_vert_glsl,
1086  NULL,
1087  datatoc_edit_uv_image_mask_frag_glsl,
1088  e_data.lib,
1089  NULL);
1090  }
1091  return sh_data->edit_uv_mask_image;
1092 }
1093 
1094 GPUShader *OVERLAY_shader_image(void)
1095 {
1096  const DRWContextState *draw_ctx = DRW_context_state_get();
1097  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1098  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1099  if (!sh_data->image) {
1100  sh_data->image = GPU_shader_create_from_arrays({
1101  .vert = (const char *[]){sh_cfg->lib,
1102  datatoc_common_view_lib_glsl,
1103  datatoc_image_vert_glsl,
1104  NULL},
1105  .frag = (const char *[]){datatoc_common_colormanagement_lib_glsl,
1106  datatoc_image_frag_glsl,
1107  NULL},
1108  .defs = (const char *[]){sh_cfg->def, NULL},
1109  });
1110  }
1111  return sh_data->image;
1112 }
1113 
1114 GPUShader *OVERLAY_shader_motion_path_line(void)
1115 {
1116  const DRWContextState *draw_ctx = DRW_context_state_get();
1117  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1118  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1119  if (!sh_data->motion_path_line) {
1120  sh_data->motion_path_line = GPU_shader_create_from_arrays({
1121  .vert = (const char *[]){sh_cfg->lib,
1122  datatoc_common_globals_lib_glsl,
1123  datatoc_common_view_lib_glsl,
1124  datatoc_motion_path_line_vert_glsl,
1125  NULL},
1126  .geom = (const char *[]){sh_cfg->lib,
1127  datatoc_common_globals_lib_glsl,
1128  datatoc_common_view_lib_glsl,
1129  datatoc_motion_path_line_geom_glsl,
1130  NULL},
1131  .frag = (const char *[]){datatoc_gpu_shader_3D_smooth_color_frag_glsl, NULL},
1132  .defs = (const char *[]){sh_cfg->def, NULL},
1133  });
1134  }
1135  return sh_data->motion_path_line;
1136 }
1137 
1138 GPUShader *OVERLAY_shader_motion_path_vert(void)
1139 {
1140  const DRWContextState *draw_ctx = DRW_context_state_get();
1141  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1142  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1143  if (!sh_data->motion_path_vert) {
1144  sh_data->motion_path_vert = GPU_shader_create_from_arrays({
1145  .vert = (const char *[]){sh_cfg->lib,
1146  datatoc_common_globals_lib_glsl,
1147  datatoc_common_view_lib_glsl,
1148  datatoc_motion_path_point_vert_glsl,
1149  NULL},
1150  .frag = (const char *[]){datatoc_gpu_shader_point_varying_color_frag_glsl, NULL},
1151  .defs = (const char *[]){sh_cfg->def, NULL},
1152  });
1153  }
1154  return sh_data->motion_path_vert;
1155 }
1156 
1157 GPUShader *OVERLAY_shader_outline_prepass(bool use_wire)
1158 {
1159  const DRWContextState *draw_ctx = DRW_context_state_get();
1160  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1161  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1162  if (use_wire && !sh_data->outline_prepass_wire) {
1163  sh_data->outline_prepass_wire = GPU_shader_create_from_arrays({
1164  .vert = (const char *[]){sh_cfg->lib,
1165  datatoc_common_view_lib_glsl,
1166  datatoc_gpu_shader_common_obinfos_lib_glsl,
1167  datatoc_outline_prepass_vert_glsl,
1168  NULL},
1169  .geom = (const char *[]){sh_cfg->lib,
1170  datatoc_common_view_lib_glsl,
1171  datatoc_outline_prepass_geom_glsl,
1172  NULL},
1173  .frag = (const char *[]){datatoc_outline_prepass_frag_glsl, NULL},
1174  .defs = (const char *[]){sh_cfg->def, "#define USE_GEOM\n", NULL},
1175  });
1176  }
1177  else if (!sh_data->outline_prepass) {
1178  sh_data->outline_prepass = GPU_shader_create_from_arrays({
1179  .vert = (const char *[]){sh_cfg->lib,
1180  datatoc_common_view_lib_glsl,
1181  datatoc_gpu_shader_common_obinfos_lib_glsl,
1182  datatoc_outline_prepass_vert_glsl,
1183  NULL},
1184  .frag = (const char *[]){datatoc_outline_prepass_frag_glsl, NULL},
1185  .defs = (const char *[]){sh_cfg->def, NULL},
1186  });
1187  }
1188  return use_wire ? sh_data->outline_prepass_wire : sh_data->outline_prepass;
1189 }
1190 
1191 GPUShader *OVERLAY_shader_outline_prepass_gpencil(void)
1192 {
1193  const DRWContextState *draw_ctx = DRW_context_state_get();
1194  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1195  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1196  if (!sh_data->outline_prepass_gpencil) {
1197  sh_data->outline_prepass_gpencil = GPU_shader_create_from_arrays({
1198  .vert = (const char *[]){sh_cfg->lib,
1199  datatoc_common_view_lib_glsl,
1200  datatoc_gpencil_common_lib_glsl,
1201  datatoc_gpu_shader_common_obinfos_lib_glsl,
1202  datatoc_outline_prepass_vert_glsl,
1203  NULL},
1204  .frag = (const char *[]){datatoc_common_view_lib_glsl,
1205  datatoc_gpencil_common_lib_glsl,
1206  datatoc_outline_prepass_frag_glsl,
1207  NULL},
1208  .defs = (const char *[]){sh_cfg->def,
1209  "#define USE_GPENCIL\n",
1210  "#define UNIFORM_RESOURCE_ID\n",
1211  NULL},
1212  });
1213  }
1214  return sh_data->outline_prepass_gpencil;
1215 }
1216 
1217 GPUShader *OVERLAY_shader_outline_prepass_pointcloud(void)
1218 {
1219  const DRWContextState *draw_ctx = DRW_context_state_get();
1220  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1221  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1222  if (!sh_data->outline_prepass_pointcloud) {
1223  sh_data->outline_prepass_pointcloud = GPU_shader_create_from_arrays({
1224  .vert = (const char *[]){sh_cfg->lib,
1225  datatoc_common_view_lib_glsl,
1226  datatoc_common_pointcloud_lib_glsl,
1227  datatoc_gpu_shader_common_obinfos_lib_glsl,
1228  datatoc_outline_prepass_vert_glsl,
1229  NULL},
1230  .frag = (const char *[]){datatoc_common_view_lib_glsl,
1231  datatoc_gpencil_common_lib_glsl,
1232  datatoc_outline_prepass_frag_glsl,
1233  NULL},
1234  .defs = (const char *[]){sh_cfg->def,
1235  "#define POINTCLOUD\n",
1236  "#define INSTANCED_ATTR\n",
1237  "#define UNIFORM_RESOURCE_ID\n",
1238  NULL},
1239  });
1240  }
1241  return sh_data->outline_prepass_pointcloud;
1242 }
1243 
1244 GPUShader *OVERLAY_shader_outline_detect(void)
1245 {
1246  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
1247  if (!sh_data->outline_detect) {
1248  sh_data->outline_detect = GPU_shader_create_from_arrays({
1249  .vert = (const char *[]){datatoc_common_fullscreen_vert_glsl, NULL},
1250  .frag = (const char *[]){datatoc_common_view_lib_glsl,
1251  datatoc_common_globals_lib_glsl,
1252  datatoc_outline_detect_frag_glsl,
1253  NULL},
1254  });
1255  }
1256  return sh_data->outline_detect;
1257 }
1258 
1259 GPUShader *OVERLAY_shader_paint_face(void)
1260 {
1261  const DRWContextState *draw_ctx = DRW_context_state_get();
1262  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1263  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1264  if (!sh_data->paint_face) {
1265  sh_data->paint_face = GPU_shader_create_from_arrays({
1266  .vert = (const char *[]){sh_cfg->lib,
1267  datatoc_common_view_lib_glsl,
1268  datatoc_paint_face_vert_glsl,
1269  NULL},
1270  .frag = (const char *[]){datatoc_gpu_shader_uniform_color_frag_glsl, NULL},
1271  .defs = (const char *[]){sh_cfg->def, NULL},
1272  });
1273  }
1274  return sh_data->paint_face;
1275 }
1276 
1277 GPUShader *OVERLAY_shader_paint_point(void)
1278 {
1279  const DRWContextState *draw_ctx = DRW_context_state_get();
1280  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1281  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1282  if (!sh_data->paint_point) {
1283  sh_data->paint_point = GPU_shader_create_from_arrays({
1284  .vert = (const char *[]){sh_cfg->lib,
1285  datatoc_common_globals_lib_glsl,
1286  datatoc_common_view_lib_glsl,
1287  datatoc_paint_point_vert_glsl,
1288  NULL},
1289  .frag = (const char *[]){datatoc_gpu_shader_point_varying_color_frag_glsl, NULL},
1290  .defs = (const char *[]){sh_cfg->def, NULL},
1291  });
1292  }
1293  return sh_data->paint_point;
1294 }
1295 
1296 GPUShader *OVERLAY_shader_paint_texture(void)
1297 {
1298  const DRWContextState *draw_ctx = DRW_context_state_get();
1299  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1300  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1301  if (!sh_data->paint_texture) {
1302  sh_data->paint_texture = GPU_shader_create_from_arrays({
1303  .vert = (const char *[]){sh_cfg->lib,
1304  datatoc_common_view_lib_glsl,
1305  datatoc_paint_texture_vert_glsl,
1306  NULL},
1307  .frag = (const char *[]){datatoc_common_colormanagement_lib_glsl,
1308  datatoc_paint_texture_frag_glsl,
1309  NULL},
1310  .defs = (const char *[]){sh_cfg->def, NULL},
1311  });
1312  }
1313  return sh_data->paint_texture;
1314 }
1315 
1316 GPUShader *OVERLAY_shader_paint_vertcol(void)
1317 {
1318  const DRWContextState *draw_ctx = DRW_context_state_get();
1319  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1320  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1321  if (!sh_data->paint_vertcol) {
1322  sh_data->paint_vertcol = GPU_shader_create_from_arrays({
1323  .vert = (const char *[]){sh_cfg->lib,
1324  datatoc_common_globals_lib_glsl,
1325  datatoc_common_view_lib_glsl,
1326  datatoc_paint_vertcol_vert_glsl,
1327  NULL},
1328  .frag = (const char *[]){datatoc_common_globals_lib_glsl,
1329  datatoc_paint_vertcol_frag_glsl,
1330  NULL},
1331  .defs = (const char *[]){sh_cfg->def, NULL},
1332  });
1333  }
1334  return sh_data->paint_vertcol;
1335 }
1336 
1337 GPUShader *OVERLAY_shader_paint_weight(void)
1338 {
1339  const DRWContextState *draw_ctx = DRW_context_state_get();
1340  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1341  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1342  if (!sh_data->paint_weight) {
1343  sh_data->paint_weight = GPU_shader_create_from_arrays({
1344  .vert = (const char *[]){sh_cfg->lib,
1345  datatoc_common_globals_lib_glsl,
1346  datatoc_common_view_lib_glsl,
1347  datatoc_paint_weight_vert_glsl,
1348  NULL},
1349  .frag = (const char *[]){datatoc_common_globals_lib_glsl,
1350  datatoc_paint_weight_frag_glsl,
1351  NULL},
1352  .defs = (const char *[]){sh_cfg->def, NULL},
1353  });
1354  }
1355  return sh_data->paint_weight;
1356 }
1357 
1358 GPUShader *OVERLAY_shader_paint_wire(void)
1359 {
1360  const DRWContextState *draw_ctx = DRW_context_state_get();
1361  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1362  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1363  if (!sh_data->paint_wire) {
1364  sh_data->paint_wire = GPU_shader_create_from_arrays({
1365  .vert = (const char *[]){sh_cfg->lib,
1366  datatoc_common_globals_lib_glsl,
1367  datatoc_common_view_lib_glsl,
1368  datatoc_paint_wire_vert_glsl,
1369  NULL},
1370  .frag = (const char *[]){datatoc_gpu_shader_flat_color_frag_glsl, NULL},
1371  .defs = (const char *[]){sh_cfg->def, NULL},
1372  });
1373  }
1374  return sh_data->paint_wire;
1375 }
1376 
1377 GPUShader *OVERLAY_shader_particle_dot(void)
1378 {
1379  const DRWContextState *draw_ctx = DRW_context_state_get();
1380  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1381  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1382  if (!sh_data->particle_dot) {
1383  sh_data->particle_dot = GPU_shader_create_from_arrays({
1384  .vert = (const char *[]){sh_cfg->lib,
1385  datatoc_common_globals_lib_glsl,
1386  datatoc_common_view_lib_glsl,
1387  datatoc_particle_vert_glsl,
1388  NULL},
1389  .frag = (const char *[]){datatoc_common_view_lib_glsl, datatoc_particle_frag_glsl, NULL},
1390  .defs = (const char *[]){sh_cfg->def, "#define USE_DOTS\n", NULL},
1391  });
1392  }
1393  return sh_data->particle_dot;
1394 }
1395 
1396 GPUShader *OVERLAY_shader_particle_shape(void)
1397 {
1398  const DRWContextState *draw_ctx = DRW_context_state_get();
1399  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1400  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1401  if (!sh_data->particle_shape) {
1402  sh_data->particle_shape = GPU_shader_create_from_arrays({
1403  .vert = (const char *[]){sh_cfg->lib,
1404  datatoc_common_globals_lib_glsl,
1405  datatoc_common_view_lib_glsl,
1406  datatoc_particle_vert_glsl,
1407  NULL},
1408  .frag = (const char *[]){datatoc_gpu_shader_flat_color_frag_glsl, NULL},
1409  .defs = (const char *[]){sh_cfg->def, "#define INSTANCED_ATTR\n", NULL},
1410  });
1411  }
1412  return sh_data->particle_shape;
1413 }
1414 
1415 GPUShader *OVERLAY_shader_sculpt_mask(void)
1416 {
1417  const DRWContextState *draw_ctx = DRW_context_state_get();
1418  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1419  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1420  if (!sh_data->sculpt_mask) {
1421  sh_data->sculpt_mask = GPU_shader_create_from_arrays({
1422  .vert = (const char *[]){sh_cfg->lib,
1423  datatoc_common_view_lib_glsl,
1424  datatoc_sculpt_mask_vert_glsl,
1425  NULL},
1426  .frag = (const char *[]){datatoc_sculpt_mask_frag_glsl, NULL},
1427  .defs = (const char *[]){sh_cfg->def, NULL},
1428  });
1429  }
1430  return sh_data->sculpt_mask;
1431 }
1432 
1433 struct GPUShader *OVERLAY_shader_uniform_color(void)
1434 {
1435  const DRWContextState *draw_ctx = DRW_context_state_get();
1436  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1437  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1438  if (!sh_data->uniform_color) {
1439  sh_data->uniform_color = GPU_shader_create_from_arrays({
1440  .vert = (const char *[]){sh_cfg->lib,
1441  datatoc_common_view_lib_glsl,
1442  datatoc_depth_only_vert_glsl,
1443  NULL},
1444  .frag = (const char *[]){datatoc_gpu_shader_uniform_color_frag_glsl, NULL},
1445  .defs = (const char *[]){sh_cfg->def, NULL},
1446  });
1447  }
1448  return sh_data->uniform_color;
1449 }
1450 
1451 struct GPUShader *OVERLAY_shader_volume_velocity(bool use_needle, bool use_mac)
1452 {
1453  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
1454  if (use_needle && !sh_data->volume_velocity_needle_sh) {
1455  sh_data->volume_velocity_needle_sh = DRW_shader_create_with_lib(
1456  datatoc_volume_velocity_vert_glsl,
1457  NULL,
1458  datatoc_gpu_shader_flat_color_frag_glsl,
1459  datatoc_common_view_lib_glsl,
1460  "#define blender_srgb_to_framebuffer_space(a) a\n"
1461  "#define USE_NEEDLE\n");
1462  }
1463  else if (use_mac && !sh_data->volume_velocity_mac_sh) {
1464  sh_data->volume_velocity_mac_sh = DRW_shader_create_with_lib(
1465  datatoc_volume_velocity_vert_glsl,
1466  NULL,
1467  datatoc_gpu_shader_3D_smooth_color_frag_glsl,
1468  datatoc_common_view_lib_glsl,
1469  "#define blender_srgb_to_framebuffer_space(a) a\n"
1470  "#define USE_MAC\n");
1471  }
1472  else if (!sh_data->volume_velocity_sh) {
1473  sh_data->volume_velocity_sh = DRW_shader_create_with_lib(
1474  datatoc_volume_velocity_vert_glsl,
1475  NULL,
1476  datatoc_gpu_shader_flat_color_frag_glsl,
1477  datatoc_common_view_lib_glsl,
1478  "#define blender_srgb_to_framebuffer_space(a) a\n");
1479  }
1480  if (use_needle) {
1481  return sh_data->volume_velocity_needle_sh;
1482  }
1483  if (use_mac) {
1484  return sh_data->volume_velocity_mac_sh;
1485  }
1486 
1487  return sh_data->volume_velocity_sh;
1488 }
1489 
1490 struct GPUShader *OVERLAY_shader_volume_gridlines(bool color_with_flags, bool color_range)
1491 {
1492  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
1493  if (!sh_data->volume_gridlines_flags_sh && color_with_flags) {
1494  sh_data->volume_gridlines_flags_sh = DRW_shader_create_with_lib(
1495  datatoc_volume_gridlines_vert_glsl,
1496  NULL,
1497  datatoc_gpu_shader_flat_color_frag_glsl,
1498  datatoc_common_view_lib_glsl,
1499  "#define blender_srgb_to_framebuffer_space(a) a\n"
1500  "#define SHOW_FLAGS\n");
1501  }
1502  else if (!sh_data->volume_gridlines_range_sh && color_range) {
1503  sh_data->volume_gridlines_range_sh = DRW_shader_create_with_lib(
1504  datatoc_volume_gridlines_vert_glsl,
1505  NULL,
1506  datatoc_gpu_shader_flat_color_frag_glsl,
1507  datatoc_common_view_lib_glsl,
1508  "#define blender_srgb_to_framebuffer_space(a) a\n"
1509  "#define SHOW_RANGE\n");
1510  }
1511  else if (!sh_data->volume_gridlines_sh) {
1512  sh_data->volume_gridlines_sh = DRW_shader_create_with_lib(
1513  datatoc_volume_gridlines_vert_glsl,
1514  NULL,
1515  datatoc_gpu_shader_flat_color_frag_glsl,
1516  datatoc_common_view_lib_glsl,
1517  "#define blender_srgb_to_framebuffer_space(a) a\n");
1518  }
1519 
1520  if (color_with_flags) {
1521  return sh_data->volume_gridlines_flags_sh;
1522  }
1523  if (color_range) {
1524  return sh_data->volume_gridlines_range_sh;
1525  }
1526 
1527  return sh_data->volume_gridlines_sh;
1528 }
1529 
1530 GPUShader *OVERLAY_shader_wireframe_select(void)
1531 {
1532  const DRWContextState *draw_ctx = DRW_context_state_get();
1533  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1534  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1535  if (!sh_data->wireframe_select) {
1536  sh_data->wireframe_select = GPU_shader_create_from_arrays({
1537  .vert = (const char *[]){sh_cfg->lib,
1538  datatoc_common_view_lib_glsl,
1539  datatoc_common_globals_lib_glsl,
1540  datatoc_gpu_shader_common_obinfos_lib_glsl,
1541  datatoc_wireframe_vert_glsl,
1542  NULL},
1543  .frag = (const char *[]){datatoc_wireframe_frag_glsl, NULL},
1544  .defs = (const char *[]){sh_cfg->def, "#define SELECT_EDGES\n", NULL},
1545  });
1546  }
1547  return sh_data->wireframe_select;
1548 }
1549 
1550 GPUShader *OVERLAY_shader_wireframe(bool custom_bias)
1551 {
1552  const DRWContextState *draw_ctx = DRW_context_state_get();
1553  const GPUShaderConfigData *sh_cfg = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
1554  OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
1555  if (!sh_data->wireframe[custom_bias]) {
1556  sh_data->wireframe[custom_bias] = GPU_shader_create_from_arrays({
1557  .vert = (const char *[]){sh_cfg->lib,
1558  datatoc_common_view_lib_glsl,
1559  datatoc_common_globals_lib_glsl,
1560  datatoc_gpu_shader_common_obinfos_lib_glsl,
1561  datatoc_wireframe_vert_glsl,
1562  NULL},
1563  .frag = (const char *[]){datatoc_common_view_lib_glsl,
1564  datatoc_common_globals_lib_glsl,
1565  datatoc_wireframe_frag_glsl,
1566  NULL},
1567  .defs = (const char *[]){sh_cfg->def,
1568  custom_bias ? "#define CUSTOM_DEPTH_BIAS\n" : NULL,
1569  NULL},
1570  });
1571  }
1572  return sh_data->wireframe[custom_bias];
1573 }
1574 
1575 GPUShader *OVERLAY_shader_xray_fade(void)
1576 {
1577  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
1578  if (!sh_data->xray_fade) {
1579  sh_data->xray_fade = GPU_shader_create_from_arrays({
1580  .vert = (const char *[]){datatoc_common_fullscreen_vert_glsl, NULL},
1581  .frag = (const char *[]){datatoc_xray_fade_frag_glsl, NULL},
1582  });
1583  }
1584  return sh_data->xray_fade;
1585 }
1586 
1587 /* -------------------------------------------------------------------- */
1591 GPUShader *OVERLAY_shader_edit_uv_edges_get(void)
1592 {
1593  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
1594  if (!sh_data->edit_uv_edges) {
1595  sh_data->edit_uv_edges = DRW_shader_create_with_shaderlib(datatoc_edit_uv_edges_vert_glsl,
1596  datatoc_edit_uv_edges_geom_glsl,
1597  datatoc_edit_uv_edges_frag_glsl,
1598  e_data.lib,
1599  NULL);
1600  }
1601  return sh_data->edit_uv_edges;
1602 }
1603 
1604 GPUShader *OVERLAY_shader_edit_uv_face_get(void)
1605 {
1606  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
1607  if (!sh_data->edit_uv_faces) {
1608  sh_data->edit_uv_faces = DRW_shader_create_with_shaderlib(
1609  datatoc_edit_uv_faces_vert_glsl,
1610  NULL,
1611  datatoc_gpu_shader_flat_color_frag_glsl,
1612  e_data.lib,
1613  "#define blender_srgb_to_framebuffer_space(a) a\n");
1614  }
1615  return sh_data->edit_uv_faces;
1616 }
1617 
1618 GPUShader *OVERLAY_shader_edit_uv_face_dots_get(void)
1619 {
1620  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
1621  if (!sh_data->edit_uv_face_dots) {
1622  sh_data->edit_uv_face_dots = DRW_shader_create_with_shaderlib(
1623  datatoc_edit_uv_face_dots_vert_glsl,
1624  NULL,
1625  datatoc_gpu_shader_flat_color_frag_glsl,
1626  e_data.lib,
1627  "#define blender_srgb_to_framebuffer_space(a) a\n");
1628  }
1629  return sh_data->edit_uv_face_dots;
1630 }
1631 
1632 GPUShader *OVERLAY_shader_edit_uv_verts_get(void)
1633 {
1634  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
1635  if (!sh_data->edit_uv_verts) {
1636  sh_data->edit_uv_verts = DRW_shader_create_with_shaderlib(
1637  datatoc_edit_uv_verts_vert_glsl, NULL, datatoc_edit_uv_verts_frag_glsl, e_data.lib, NULL);
1638  }
1639 
1640  return sh_data->edit_uv_verts;
1641 }
1642 
1643 GPUShader *OVERLAY_shader_edit_uv_stretching_area_get(void)
1644 {
1645  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
1646  if (!sh_data->edit_uv_stretching_area) {
1647  sh_data->edit_uv_stretching_area = DRW_shader_create_with_shaderlib(
1648  datatoc_edit_uv_stretching_vert_glsl,
1649  NULL,
1650  datatoc_gpu_shader_2D_smooth_color_frag_glsl,
1651  e_data.lib,
1652  "#define blender_srgb_to_framebuffer_space(a) a\n");
1653  }
1654 
1655  return sh_data->edit_uv_stretching_area;
1656 }
1657 
1658 GPUShader *OVERLAY_shader_edit_uv_stretching_angle_get(void)
1659 {
1660  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
1661  if (!sh_data->edit_uv_stretching_angle) {
1662  sh_data->edit_uv_stretching_angle = DRW_shader_create_with_shaderlib(
1663  datatoc_edit_uv_stretching_vert_glsl,
1664  NULL,
1665  datatoc_gpu_shader_2D_smooth_color_frag_glsl,
1666  e_data.lib,
1667  "#define blender_srgb_to_framebuffer_space(a) a\n#define STRETCH_ANGLE\n");
1668  }
1669 
1670  return sh_data->edit_uv_stretching_angle;
1671 }
1672 
1673 GPUShader *OVERLAY_shader_edit_uv_tiled_image_borders_get(void)
1674 {
1675  OVERLAY_Shaders *sh_data = &e_data.sh_data[0];
1676  if (!sh_data->edit_uv_tiled_image_borders) {
1677  sh_data->edit_uv_tiled_image_borders = DRW_shader_create_with_shaderlib(
1678  datatoc_edit_uv_tiled_image_borders_vert_glsl,
1679  NULL,
1680  datatoc_gpu_shader_uniform_color_frag_glsl,
1681  e_data.lib,
1682  "#define blender_srgb_to_framebuffer_space(a) a\n");
1683  }
1684  return sh_data->edit_uv_tiled_image_borders;
1685 }
1686 
1689 static OVERLAY_InstanceFormats g_formats = {NULL};
1690 
1691 OVERLAY_InstanceFormats *OVERLAY_shader_instance_formats_get(void)
1692 {
1693  DRW_shgroup_instance_format(g_formats.pos,
1694  {
1695  {"pos", DRW_ATTR_FLOAT, 3},
1696  });
1697  DRW_shgroup_instance_format(g_formats.pos_color,
1698  {
1699  {"pos", DRW_ATTR_FLOAT, 3},
1700  {"color", DRW_ATTR_FLOAT, 4},
1701  });
1702  DRW_shgroup_instance_format(g_formats.instance_pos,
1703  {
1704  {"inst_pos", DRW_ATTR_FLOAT, 3},
1705  });
1706  DRW_shgroup_instance_format(g_formats.instance_extra,
1707  {
1708  {"color", DRW_ATTR_FLOAT, 4},
1709  {"inst_obmat", DRW_ATTR_FLOAT, 16},
1710  });
1711  DRW_shgroup_instance_format(g_formats.wire_extra,
1712  {
1713  {"pos", DRW_ATTR_FLOAT, 3},
1714  {"colorid", DRW_ATTR_INT, 1},
1715  });
1716  DRW_shgroup_instance_format(g_formats.point_extra,
1717  {
1718  {"pos", DRW_ATTR_FLOAT, 3},
1719  {"colorid", DRW_ATTR_INT, 1},
1720  });
1721  DRW_shgroup_instance_format(g_formats.instance_bone,
1722  {
1723  {"inst_obmat", DRW_ATTR_FLOAT, 16},
1724  });
1725  DRW_shgroup_instance_format(g_formats.instance_bone_stick,
1726  {
1727  {"boneStart", DRW_ATTR_FLOAT, 3},
1728  {"boneEnd", DRW_ATTR_FLOAT, 3},
1729  {"wireColor", DRW_ATTR_FLOAT, 4}, /* TODO uchar color */
1730  {"boneColor", DRW_ATTR_FLOAT, 4},
1731  {"headColor", DRW_ATTR_FLOAT, 4},
1732  {"tailColor", DRW_ATTR_FLOAT, 4},
1733  });
1734  DRW_shgroup_instance_format(g_formats.instance_bone_envelope_outline,
1735  {
1736  {"headSphere", DRW_ATTR_FLOAT, 4},
1737  {"tailSphere", DRW_ATTR_FLOAT, 4},
1738  {"outlineColorSize", DRW_ATTR_FLOAT, 4},
1739  {"xAxis", DRW_ATTR_FLOAT, 3},
1740  });
1741  DRW_shgroup_instance_format(g_formats.instance_bone_envelope_distance,
1742  {
1743  {"headSphere", DRW_ATTR_FLOAT, 4},
1744  {"tailSphere", DRW_ATTR_FLOAT, 4},
1745  {"xAxis", DRW_ATTR_FLOAT, 3},
1746  });
1747  DRW_shgroup_instance_format(g_formats.instance_bone_envelope,
1748  {
1749  {"headSphere", DRW_ATTR_FLOAT, 4},
1750  {"tailSphere", DRW_ATTR_FLOAT, 4},
1751  {"boneColor", DRW_ATTR_FLOAT, 3},
1752  {"stateColor", DRW_ATTR_FLOAT, 3},
1753  {"xAxis", DRW_ATTR_FLOAT, 3},
1754  });
1755 
1756  return &g_formats;
1757 }
1758 
1759 void OVERLAY_shader_free(void)
1760 {
1761  DRW_SHADER_LIB_FREE_SAFE(e_data.lib);
1762 
1763  for (int sh_data_index = 0; sh_data_index < ARRAY_SIZE(e_data.sh_data); sh_data_index++) {
1764  OVERLAY_Shaders *sh_data = &e_data.sh_data[sh_data_index];
1765  GPUShader **sh_data_as_array = (GPUShader **)sh_data;
1766  for (int i = 0; i < (sizeof(OVERLAY_Shaders) / sizeof(GPUShader *)); i++) {
1767  DRW_SHADER_FREE_SAFE(sh_data_as_array[i]);
1768  }
1769  }
1770  struct GPUVertFormat **format = (struct GPUVertFormat **)&g_formats;
1771  for (int i = 0; i < sizeof(g_formats) / sizeof(void *); i++, format++) {
1772  MEM_SAFE_FREE(*format);
1773  }
1774 }
BLI_snprintf
size_t BLI_snprintf(char *__restrict dst, size_t maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
ARRAY_SIZE
#define ARRAY_SIZE(arr)
Definition: BLI_utildefines.h:517
USER_GPU_FLAG_NO_EDIT_MODE_SMOOTH_WIRE
@ USER_GPU_FLAG_NO_EDIT_MODE_SMOOTH_WIRE
Definition: DNA_userdef_types.h:1116
DRW_render.h
DRW_shader_create_with_lib
#define DRW_shader_create_with_lib(vert, geom, frag, lib, defines)
Definition: DRW_render.h:237
DRW_shgroup_instance_format
#define DRW_shgroup_instance_format(format,...)
Definition: DRW_render.h:391
DRW_SHADER_LIB_FREE_SAFE
#define DRW_SHADER_LIB_FREE_SAFE(lib)
Definition: DRW_render.h:298
DRW_SHADER_LIB_ADD
#define DRW_SHADER_LIB_ADD(lib, lib_name)
Definition: DRW_render.h:291
DRW_SHADER_FREE_SAFE
#define DRW_SHADER_FREE_SAFE(shader)
Definition: DRW_render.h:279
DRW_shader_create_with_shaderlib
#define DRW_shader_create_with_shaderlib(vert, geom, frag, lib, defines)
Definition: DRW_render.h:239
GPU_shader.h
GPUShader
struct GPUShader GPUShader
Definition: GPU_shader.h:33
GPU_shader_cfg_data
const GPUShaderConfigData GPU_shader_cfg_data[GPU_SHADER_CFG_LEN]
Definition: gpu_shader_builtin.c:136
GPU_shader_create_from_arrays
#define GPU_shader_create_from_arrays(...)
Definition: GPU_shader.h:69
GPU_SHADER_CFG_LEN
#define GPU_SHADER_CFG_LEN
Definition: GPU_shader.h:395
MEM_SAFE_FREE
#define MEM_SAFE_FREE(v)
Definition: MEM_guardedalloc.h:201
UI_resources.h
TH_WIRE
@ TH_WIRE
Definition: UI_resources.h:85
TH_TRANSFORM
@ TH_TRANSFORM
Definition: UI_resources.h:92
TH_CAMERA_PATH
@ TH_CAMERA_PATH
Definition: UI_resources.h:254
TH_SELECT
@ TH_SELECT
Definition: UI_resources.h:88
TH_ACTIVE
@ TH_ACTIVE
Definition: UI_resources.h:89
NULL
return NULL
Definition: bmesh_operator_api_inline.h:224
if
if(data)
Definition: bmesh_operator_api_inline.h:177
U
unsigned int U
Definition: btGjkEpa3.h:78
DRW_context_state_get
const DRWContextState * DRW_context_state_get(void)
Definition: draw_manager.c:2902
DRW_shader_library_create
DRWShaderLibrary * DRW_shader_library_create(void)
Definition: draw_manager_shader.c:574
format
format
Definition: logImageCore.h:47
overlay_private.h
datatoc_gpu_shader_uniform_color_frag_glsl
char datatoc_gpu_shader_uniform_color_frag_glsl[]
OVERLAY_shader_edit_lattice_wire
GPUShader * OVERLAY_shader_edit_lattice_wire(void)
Definition: overlay_shader.c:713
datatoc_armature_shape_solid_frag_glsl
char datatoc_armature_shape_solid_frag_glsl[]
datatoc_extra_groundline_vert_glsl
char datatoc_extra_groundline_vert_glsl[]
datatoc_paint_wire_vert_glsl
char datatoc_paint_wire_vert_glsl[]
datatoc_antialiasing_vert_glsl
char datatoc_antialiasing_vert_glsl[]
datatoc_edit_gpencil_guide_vert_glsl
char datatoc_edit_gpencil_guide_vert_glsl[]
datatoc_extra_point_vert_glsl
char datatoc_extra_point_vert_glsl[]
datatoc_gpu_shader_common_obinfos_lib_glsl
char datatoc_gpu_shader_common_obinfos_lib_glsl[]
datatoc_gpu_shader_3D_smooth_color_frag_glsl
char datatoc_gpu_shader_3D_smooth_color_frag_glsl[]
OVERLAY_shader_edit_uv_stretching_angle_get
GPUShader * OVERLAY_shader_edit_uv_stretching_angle_get(void)
Definition: overlay_shader.c:1658
datatoc_wireframe_frag_glsl
char datatoc_wireframe_frag_glsl[]
datatoc_armature_envelope_solid_frag_glsl
char datatoc_armature_envelope_solid_frag_glsl[]
datatoc_edit_mesh_geom_glsl
char datatoc_edit_mesh_geom_glsl[]
datatoc_common_pointcloud_lib_glsl
char datatoc_common_pointcloud_lib_glsl[]
datatoc_edit_particle_point_vert_glsl
char datatoc_edit_particle_point_vert_glsl[]
datatoc_common_fxaa_lib_glsl
char datatoc_common_fxaa_lib_glsl[]
datatoc_armature_shape_solid_vert_glsl
char datatoc_armature_shape_solid_vert_glsl[]
OVERLAY_shader_image
GPUShader * OVERLAY_shader_image(void)
Definition: overlay_shader.c:1094
OVERLAY_shader_library_ensure
void OVERLAY_shader_library_ensure(void)
Definition: overlay_shader.c:237
datatoc_clipbound_vert_glsl
char datatoc_clipbound_vert_glsl[]
datatoc_edit_curve_handle_vert_glsl
char datatoc_edit_curve_handle_vert_glsl[]
datatoc_sculpt_mask_frag_glsl
char datatoc_sculpt_mask_frag_glsl[]
OVERLAY_shader_edit_curve_handle
GPUShader * OVERLAY_shader_edit_curve_handle(void)
Definition: overlay_shader.c:580
OVERLAY_shader_free
void OVERLAY_shader_free(void)
Definition: overlay_shader.c:1759
datatoc_armature_envelope_solid_vert_glsl
char datatoc_armature_envelope_solid_vert_glsl[]
datatoc_edit_curve_point_vert_glsl
char datatoc_edit_curve_point_vert_glsl[]
datatoc_background_frag_glsl
char datatoc_background_frag_glsl[]
OVERLAY_shader_armature_degrees_of_freedom_wire
GPUShader * OVERLAY_shader_armature_degrees_of_freedom_wire(void)
Definition: overlay_shader.c:519
datatoc_armature_sphere_solid_frag_glsl
char datatoc_armature_sphere_solid_frag_glsl[]
datatoc_xray_fade_frag_glsl
char datatoc_xray_fade_frag_glsl[]
datatoc_gpu_shader_depth_only_frag_glsl
char datatoc_gpu_shader_depth_only_frag_glsl[]
OVERLAY_shader_edit_gpencil_guide_point
GPUShader * OVERLAY_shader_edit_gpencil_guide_point(void)
Definition: overlay_shader.c:642
datatoc_particle_frag_glsl
char datatoc_particle_frag_glsl[]
OVERLAY_shader_edit_lattice_point
GPUShader * OVERLAY_shader_edit_lattice_point(void)
Definition: overlay_shader.c:694
OVERLAY_Shaders
struct OVERLAY_Shaders OVERLAY_Shaders
datatoc_armature_shape_outline_vert_glsl
char datatoc_armature_shape_outline_vert_glsl[]
datatoc_paint_texture_frag_glsl
char datatoc_paint_texture_frag_glsl[]
OVERLAY_shader_edit_mesh_edge
GPUShader * OVERLAY_shader_edit_mesh_edge(bool use_flat_interp)
Definition: overlay_shader.c:331
datatoc_armature_sphere_solid_vert_glsl
char datatoc_armature_sphere_solid_vert_glsl[]
datatoc_edit_uv_tiled_image_borders_vert_glsl
char datatoc_edit_uv_tiled_image_borders_vert_glsl[]
OVERLAY_shader_paint_face
GPUShader * OVERLAY_shader_paint_face(void)
Definition: overlay_shader.c:1259
datatoc_grid_frag_glsl
char datatoc_grid_frag_glsl[]
datatoc_common_smaa_lib_glsl
char datatoc_common_smaa_lib_glsl[]
datatoc_paint_weight_vert_glsl
char datatoc_paint_weight_vert_glsl[]
datatoc_extra_wire_frag_glsl
char datatoc_extra_wire_frag_glsl[]
OVERLAY_shader_edit_uv_face_get
GPUShader * OVERLAY_shader_edit_uv_face_get(void)
Definition: overlay_shader.c:1604
datatoc_armature_envelope_distance_frag_glsl
char datatoc_armature_envelope_distance_frag_glsl[]
OVERLAY_shader_armature_sphere
GPUShader * OVERLAY_shader_armature_sphere(bool use_outline)
Definition: overlay_shader.c:379
datatoc_armature_sphere_outline_vert_glsl
char datatoc_armature_sphere_outline_vert_glsl[]
OVERLAY_shader_wireframe
GPUShader * OVERLAY_shader_wireframe(bool custom_bias)
Definition: overlay_shader.c:1550
OVERLAY_shader_edit_gpencil_point
GPUShader * OVERLAY_shader_edit_gpencil_point(void)
Definition: overlay_shader.c:656
datatoc_paint_weight_frag_glsl
char datatoc_paint_weight_frag_glsl[]
datatoc_facing_frag_glsl
char datatoc_facing_frag_glsl[]
datatoc_facing_vert_glsl
char datatoc_facing_vert_glsl[]
OVERLAY_shader_edit_curve_wire
GPUShader * OVERLAY_shader_edit_curve_wire(void)
Definition: overlay_shader.c:623
OVERLAY_shader_outline_prepass
GPUShader * OVERLAY_shader_outline_prepass(bool use_wire)
Definition: overlay_shader.c:1157
datatoc_wireframe_vert_glsl
char datatoc_wireframe_vert_glsl[]
OVERLAY_shader_edit_mesh_facedot
GPUShader * OVERLAY_shader_edit_mesh_facedot(void)
Definition: overlay_shader.c:752
datatoc_motion_path_line_geom_glsl
char datatoc_motion_path_line_geom_glsl[]
datatoc_extra_loose_point_vert_glsl
char datatoc_extra_loose_point_vert_glsl[]
OVERLAY_shader_extra_groundline
GPUShader * OVERLAY_shader_extra_groundline(void)
Definition: overlay_shader.c:906
datatoc_extra_loose_point_frag_glsl
char datatoc_extra_loose_point_frag_glsl[]
OVERLAY_shader_extra_loose_point
GPUShader * OVERLAY_shader_extra_loose_point(void)
Definition: overlay_shader.c:963
OVERLAY_shader_armature_degrees_of_freedom_solid
GPUShader * OVERLAY_shader_armature_degrees_of_freedom_solid(void)
Definition: overlay_shader.c:539
OVERLAY_shader_edit_uv_stencil_image
GPUShader * OVERLAY_shader_edit_uv_stencil_image(void)
Definition: overlay_shader.c:1070
sh_data
OVERLAY_Shaders sh_data[GPU_SHADER_CFG_LEN]
Definition: overlay_shader.c:233
datatoc_edit_mesh_analysis_frag_glsl
char datatoc_edit_mesh_analysis_frag_glsl[]
datatoc_edit_uv_edges_frag_glsl
char datatoc_edit_uv_edges_frag_glsl[]
OVERLAY_shader_edit_gpencil_wire
GPUShader * OVERLAY_shader_edit_gpencil_wire(void)
Definition: overlay_shader.c:675
OVERLAY_shader_background
GPUShader * OVERLAY_shader_background(void)
Definition: overlay_shader.c:266
datatoc_paint_face_vert_glsl
char datatoc_paint_face_vert_glsl[]
OVERLAY_shader_clipbound
GPUShader * OVERLAY_shader_clipbound(void)
Definition: overlay_shader.c:279
datatoc_edit_uv_verts_frag_glsl
char datatoc_edit_uv_verts_frag_glsl[]
OVERLAY_shader_edit_uv_face_dots_get
GPUShader * OVERLAY_shader_edit_uv_face_dots_get(void)
Definition: overlay_shader.c:1618
OVERLAY_shader_volume_velocity
struct GPUShader * OVERLAY_shader_volume_velocity(bool use_needle, bool use_mac)
Definition: overlay_shader.c:1451
datatoc_outline_prepass_frag_glsl
char datatoc_outline_prepass_frag_glsl[]
datatoc_armature_shape_wire_vert_glsl
char datatoc_armature_shape_wire_vert_glsl[]
datatoc_edit_particle_strand_vert_glsl
char datatoc_edit_particle_strand_vert_glsl[]
datatoc_sculpt_mask_vert_glsl
char datatoc_sculpt_mask_vert_glsl[]
datatoc_edit_uv_image_mask_frag_glsl
char datatoc_edit_uv_image_mask_frag_glsl[]
datatoc_edit_uv_face_dots_vert_glsl
char datatoc_edit_uv_face_dots_vert_glsl[]
OVERLAY_shader_motion_path_vert
GPUShader * OVERLAY_shader_motion_path_vert(void)
Definition: overlay_shader.c:1138
OVERLAY_shader_particle_dot
GPUShader * OVERLAY_shader_particle_dot(void)
Definition: overlay_shader.c:1377
datatoc_armature_stick_frag_glsl
char datatoc_armature_stick_frag_glsl[]
datatoc_edit_uv_edges_geom_glsl
char datatoc_edit_uv_edges_geom_glsl[]
datatoc_motion_path_point_vert_glsl
char datatoc_motion_path_point_vert_glsl[]
datatoc_edit_mesh_normal_vert_glsl
char datatoc_edit_mesh_normal_vert_glsl[]
datatoc_image_vert_glsl
char datatoc_image_vert_glsl[]
datatoc_common_view_lib_glsl
char datatoc_common_view_lib_glsl[]
Definition: intern/ghost/test/multitest/stubs.c:59
datatoc_extra_vert_glsl
char datatoc_extra_vert_glsl[]
OVERLAY_shader_paint_point
GPUShader * OVERLAY_shader_paint_point(void)
Definition: overlay_shader.c:1277
OVERLAY_shader_edit_mesh_skin_root
GPUShader * OVERLAY_shader_edit_mesh_skin_root(void)
Definition: overlay_shader.c:809
OVERLAY_shader_extra_grid
GPUShader * OVERLAY_shader_extra_grid(void)
Definition: overlay_shader.c:886
datatoc_edit_uv_stretching_vert_glsl
char datatoc_edit_uv_stretching_vert_glsl[]
datatoc_armature_dof_solid_frag_glsl
char datatoc_armature_dof_solid_frag_glsl[]
datatoc_edit_uv_image_vert_glsl
char datatoc_edit_uv_image_vert_glsl[]
datatoc_depth_only_vert_glsl
char datatoc_depth_only_vert_glsl[]
OVERLAY_shader_volume_gridlines
struct GPUShader * OVERLAY_shader_volume_gridlines(bool color_with_flags, bool color_range)
Definition: overlay_shader.c:1490
OVERLAY_shader_edit_uv_stretching_area_get
GPUShader * OVERLAY_shader_edit_uv_stretching_area_get(void)
Definition: overlay_shader.c:1643
datatoc_common_fullscreen_vert_glsl
char datatoc_common_fullscreen_vert_glsl[]
datatoc_extra_lightprobe_grid_vert_glsl
char datatoc_extra_lightprobe_grid_vert_glsl[]
OVERLAY_shader_particle_shape
GPUShader * OVERLAY_shader_particle_shape(void)
Definition: overlay_shader.c:1396
OVERLAY_shader_motion_path_line
GPUShader * OVERLAY_shader_motion_path_line(void)
Definition: overlay_shader.c:1114
datatoc_edit_mesh_skin_root_vert_glsl
char datatoc_edit_mesh_skin_root_vert_glsl[]
OVERLAY_shader_edit_mesh_vert
GPUShader * OVERLAY_shader_edit_mesh_vert(void)
Definition: overlay_shader.c:311
OVERLAY_shader_paint_weight
GPUShader * OVERLAY_shader_paint_weight(void)
Definition: overlay_shader.c:1337
OVERLAY_shader_edit_uv_verts_get
GPUShader * OVERLAY_shader_edit_uv_verts_get(void)
Definition: overlay_shader.c:1632
datatoc_paint_vertcol_frag_glsl
char datatoc_paint_vertcol_frag_glsl[]
datatoc_edit_mesh_common_lib_glsl
char datatoc_edit_mesh_common_lib_glsl[]
datatoc_edit_uv_faces_vert_glsl
char datatoc_edit_uv_faces_vert_glsl[]
OVERLAY_shader_extra
GPUShader * OVERLAY_shader_extra(bool is_select)
Definition: overlay_shader.c:866
OVERLAY_shader_edit_particle_strand
GPUShader * OVERLAY_shader_edit_particle_strand(void)
Definition: overlay_shader.c:828
OVERLAY_shader_extra_wire
GPUShader * OVERLAY_shader_extra_wire(bool use_object, bool is_select)
Definition: overlay_shader.c:925
lib
DRWShaderLibrary * lib
Definition: overlay_shader.c:234
datatoc_gpu_shader_point_varying_color_frag_glsl
char datatoc_gpu_shader_point_varying_color_frag_glsl[]
datatoc_edit_lattice_wire_vert_glsl
char datatoc_edit_lattice_wire_vert_glsl[]
OVERLAY_shader_sculpt_mask
GPUShader * OVERLAY_shader_sculpt_mask(void)
Definition: overlay_shader.c:1415
OVERLAY_shader_edit_uv_mask_image
GPUShader * OVERLAY_shader_edit_uv_mask_image(void)
Definition: overlay_shader.c:1080
OVERLAY_shader_armature_shape_wire
GPUShader * OVERLAY_shader_armature_shape_wire(void)
Definition: overlay_shader.c:450
datatoc_outline_prepass_geom_glsl
char datatoc_outline_prepass_geom_glsl[]
datatoc_motion_path_line_vert_glsl
char datatoc_motion_path_line_vert_glsl[]
datatoc_antialiasing_frag_glsl
char datatoc_antialiasing_frag_glsl[]
datatoc_paint_point_vert_glsl
char datatoc_paint_point_vert_glsl[]
datatoc_paint_vertcol_vert_glsl
char datatoc_paint_vertcol_vert_glsl[]
OVERLAY_shader_edit_uv_edges_get
GPUShader * OVERLAY_shader_edit_uv_edges_get(void)
Definition: overlay_shader.c:1591
datatoc_common_colormanagement_lib_glsl
char datatoc_common_colormanagement_lib_glsl[]
datatoc_armature_wire_vert_glsl
char datatoc_armature_wire_vert_glsl[]
OVERLAY_shader_edit_mesh_face
GPUShader * OVERLAY_shader_edit_mesh_face(void)
Definition: overlay_shader.c:732
datatoc_common_globals_lib_glsl
char datatoc_common_globals_lib_glsl[]
datatoc_gpu_shader_point_varying_color_varying_outline_aa_frag_glsl
char datatoc_gpu_shader_point_varying_color_varying_outline_aa_frag_glsl[]
OVERLAY_shader_edit_mesh_normal
GPUShader * OVERLAY_shader_edit_mesh_normal(void)
Definition: overlay_shader.c:772
OVERLAY_shader_armature_shape
GPUShader * OVERLAY_shader_armature_shape(bool use_outline)
Definition: overlay_shader.c:415
OVERLAY_shader_xray_fade
GPUShader * OVERLAY_shader_xray_fade(void)
Definition: overlay_shader.c:1575
datatoc_armature_wire_frag_glsl
char datatoc_armature_wire_frag_glsl[]
OVERLAY_shader_armature_wire
GPUShader * OVERLAY_shader_armature_wire(void)
Definition: overlay_shader.c:560
OVERLAY_shader_grid
GPUShader * OVERLAY_shader_grid(void)
Definition: overlay_shader.c:1038
datatoc_extra_frag_glsl
char datatoc_extra_frag_glsl[]
OVERLAY_shader_edit_curve_point
GPUShader * OVERLAY_shader_edit_curve_point(void)
Definition: overlay_shader.c:604
OVERLAY_shader_depth_only
GPUShader * OVERLAY_shader_depth_only(void)
Definition: overlay_shader.c:293
OVERLAY_shader_paint_wire
GPUShader * OVERLAY_shader_paint_wire(void)
Definition: overlay_shader.c:1358
datatoc_volume_velocity_vert_glsl
char datatoc_volume_velocity_vert_glsl[]
OVERLAY_shader_armature_envelope
GPUShader * OVERLAY_shader_armature_envelope(bool use_outline)
Definition: overlay_shader.c:470
datatoc_edit_lattice_point_vert_glsl
char datatoc_edit_lattice_point_vert_glsl[]
OVERLAY_shader_edit_particle_point
GPUShader * OVERLAY_shader_edit_particle_point(void)
Definition: overlay_shader.c:847
OVERLAY_shader_edit_uv_tiled_image_borders_get
GPUShader * OVERLAY_shader_edit_uv_tiled_image_borders_get(void)
Definition: overlay_shader.c:1673
datatoc_armature_dof_vert_glsl
char datatoc_armature_dof_vert_glsl[]
datatoc_edit_uv_verts_vert_glsl
char datatoc_edit_uv_verts_vert_glsl[]
datatoc_extra_wire_vert_glsl
char datatoc_extra_wire_vert_glsl[]
datatoc_edit_curve_handle_geom_glsl
char datatoc_edit_curve_handle_geom_glsl[]
OVERLAY_shader_paint_vertcol
GPUShader * OVERLAY_shader_paint_vertcol(void)
Definition: overlay_shader.c:1316
datatoc_grid_vert_glsl
char datatoc_grid_vert_glsl[]
datatoc_outline_detect_frag_glsl
char datatoc_outline_detect_frag_glsl[]
OVERLAY_shader_extra_point
GPUShader * OVERLAY_shader_extra_point(void)
Definition: overlay_shader.c:984
datatoc_edit_curve_wire_vert_glsl
char datatoc_edit_curve_wire_vert_glsl[]
datatoc_paint_texture_vert_glsl
char datatoc_paint_texture_vert_glsl[]
datatoc_image_frag_glsl
char datatoc_image_frag_glsl[]
OVERLAY_shader_grid_image
GPUShader * OVERLAY_shader_grid_image(void)
Definition: overlay_shader.c:1056
datatoc_edit_uv_edges_vert_glsl
char datatoc_edit_uv_edges_vert_glsl[]
OVERLAY_shader_outline_prepass_gpencil
GPUShader * OVERLAY_shader_outline_prepass_gpencil(void)
Definition: overlay_shader.c:1191
OVERLAY_shader_antialiasing
GPUShader * OVERLAY_shader_antialiasing(void)
Definition: overlay_shader.c:249
datatoc_gpu_shader_2D_smooth_color_frag_glsl
char datatoc_gpu_shader_2D_smooth_color_frag_glsl[]
datatoc_armature_stick_vert_glsl
char datatoc_armature_stick_vert_glsl[]
datatoc_armature_envelope_outline_vert_glsl
char datatoc_armature_envelope_outline_vert_glsl[]
e_data
static struct @254 e_data
OVERLAY_shader_outline_prepass_pointcloud
GPUShader * OVERLAY_shader_outline_prepass_pointcloud(void)
Definition: overlay_shader.c:1217
OVERLAY_shader_gpencil_canvas
GPUShader * OVERLAY_shader_gpencil_canvas(void)
Definition: overlay_shader.c:1023
datatoc_edit_mesh_analysis_vert_glsl
char datatoc_edit_mesh_analysis_vert_glsl[]
OVERLAY_shader_uniform_color
struct GPUShader * OVERLAY_shader_uniform_color(void)
Definition: overlay_shader.c:1433
datatoc_edit_gpencil_canvas_vert_glsl
char datatoc_edit_gpencil_canvas_vert_glsl[]
OVERLAY_shader_outline_detect
GPUShader * OVERLAY_shader_outline_detect(void)
Definition: overlay_shader.c:1244
datatoc_edit_mesh_vert_glsl
char datatoc_edit_mesh_vert_glsl[]
datatoc_outline_prepass_vert_glsl
char datatoc_outline_prepass_vert_glsl[]
datatoc_edit_gpencil_vert_glsl
char datatoc_edit_gpencil_vert_glsl[]
datatoc_gpu_shader_flat_color_frag_glsl
char datatoc_gpu_shader_flat_color_frag_glsl[]
datatoc_gpencil_common_lib_glsl
char datatoc_gpencil_common_lib_glsl[]
datatoc_common_overlay_lib_glsl
char datatoc_common_overlay_lib_glsl[]
datatoc_particle_vert_glsl
char datatoc_particle_vert_glsl[]
OVERLAY_shader_armature_stick
GPUShader * OVERLAY_shader_armature_stick(void)
Definition: overlay_shader.c:500
OVERLAY_shader_instance_formats_get
OVERLAY_InstanceFormats * OVERLAY_shader_instance_formats_get(void)
Definition: overlay_shader.c:1691
OVERLAY_shader_facing
GPUShader * OVERLAY_shader_facing(void)
Definition: overlay_shader.c:1005
datatoc_edit_mesh_frag_glsl
char datatoc_edit_mesh_frag_glsl[]
g_formats
static OVERLAY_InstanceFormats g_formats
Definition: overlay_shader.c:1689
OVERLAY_shader_paint_texture
GPUShader * OVERLAY_shader_paint_texture(void)
Definition: overlay_shader.c:1296
datatoc_armature_shape_outline_geom_glsl
char datatoc_armature_shape_outline_geom_glsl[]
OVERLAY_shader_edit_mesh_analysis
GPUShader * OVERLAY_shader_edit_mesh_analysis(void)
Definition: overlay_shader.c:791
OVERLAY_shader_wireframe_select
GPUShader * OVERLAY_shader_wireframe_select(void)
Definition: overlay_shader.c:1530
datatoc_volume_gridlines_vert_glsl
char datatoc_volume_gridlines_vert_glsl[]
DRWContextState::sh_cfg
eGPUShaderConfig sh_cfg
Definition: DRW_render.h:759
GPUShaderConfigData::lib
const char * lib
Definition: GPU_shader.h:398
GPUShaderConfigData::def
const char * def
Definition: GPU_shader.h:399
OVERLAY_InstanceFormats
Definition: overlay_private.h:460
OVERLAY_InstanceFormats::point_extra
struct GPUVertFormat * point_extra
Definition: overlay_private.h:472
OVERLAY_InstanceFormats::instance_bone_envelope_outline
struct GPUVertFormat * instance_bone_envelope_outline
Definition: overlay_private.h:467
OVERLAY_InstanceFormats::instance_bone
struct GPUVertFormat * instance_bone
Definition: overlay_private.h:463
OVERLAY_InstanceFormats::pos
struct GPUVertFormat * pos
Definition: overlay_private.h:469
OVERLAY_InstanceFormats::pos_color
struct GPUVertFormat * pos_color
Definition: overlay_private.h:470
OVERLAY_InstanceFormats::instance_extra
struct GPUVertFormat * instance_extra
Definition: overlay_private.h:462
OVERLAY_InstanceFormats::wire_extra
struct GPUVertFormat * wire_extra
Definition: overlay_private.h:471
OVERLAY_InstanceFormats::instance_pos
struct GPUVertFormat * instance_pos
Definition: overlay_private.h:461
OVERLAY_InstanceFormats::instance_bone_envelope
struct GPUVertFormat * instance_bone_envelope
Definition: overlay_private.h:465
OVERLAY_InstanceFormats::instance_bone_stick
struct GPUVertFormat * instance_bone_stick
Definition: overlay_private.h:468
OVERLAY_InstanceFormats::instance_bone_envelope_distance
struct GPUVertFormat * instance_bone_envelope_distance
Definition: overlay_private.h:466
OVERLAY_Shaders
Definition: overlay_shader.c:145
OVERLAY_Shaders::image
GPUShader * image
Definition: overlay_shader.c:202
OVERLAY_Shaders::edit_curve_handle
GPUShader * edit_curve_handle
Definition: overlay_shader.c:161
OVERLAY_Shaders::edit_uv_stencil_image
GPUShader * edit_uv_stencil_image
Definition: overlay_shader.c:188
OVERLAY_Shaders::edit_mesh_face
GPUShader * edit_mesh_face
Definition: overlay_shader.c:172
OVERLAY_Shaders::edit_uv_face_dots
GPUShader * edit_uv_face_dots
Definition: overlay_shader.c:184
OVERLAY_Shaders::volume_gridlines_sh
GPUShader * volume_gridlines_sh
Definition: overlay_shader.c:224
OVERLAY_Shaders::armature_envelope_solid
GPUShader * armature_envelope_solid
Definition: overlay_shader.c:150
OVERLAY_Shaders::edit_uv_faces
GPUShader * edit_uv_faces
Definition: overlay_shader.c:182
OVERLAY_Shaders::edit_particle_strand
GPUShader * edit_particle_strand
Definition: overlay_shader.c:179
OVERLAY_Shaders::grid_image
GPUShader * grid_image
Definition: overlay_shader.c:201
OVERLAY_Shaders::volume_velocity_mac_sh
GPUShader * volume_velocity_mac_sh
Definition: overlay_shader.c:222
OVERLAY_Shaders::paint_face
GPUShader * paint_face
Definition: overlay_shader.c:210
OVERLAY_Shaders::depth_only
GPUShader * depth_only
Definition: overlay_shader.c:160
OVERLAY_Shaders::clipbound
GPUShader * clipbound
Definition: overlay_shader.c:159
OVERLAY_Shaders::paint_vertcol
GPUShader * paint_vertcol
Definition: overlay_shader.c:213
OVERLAY_Shaders::wireframe_select
GPUShader * wireframe_select
Definition: overlay_shader.c:227
OVERLAY_Shaders::edit_mesh_normals
GPUShader * edit_mesh_normals
Definition: overlay_shader.c:176
OVERLAY_Shaders::outline_prepass_pointcloud
GPUShader * outline_prepass_pointcloud
Definition: overlay_shader.c:207
OVERLAY_Shaders::edit_uv_verts
GPUShader * edit_uv_verts
Definition: overlay_shader.c:181
OVERLAY_Shaders::edit_uv_stretching_angle
GPUShader * edit_uv_stretching_angle
Definition: overlay_shader.c:185
OVERLAY_Shaders::motion_path_vert
GPUShader * motion_path_vert
Definition: overlay_shader.c:204
OVERLAY_Shaders::outline_detect
GPUShader * outline_detect
Definition: overlay_shader.c:209
OVERLAY_Shaders::grid
GPUShader * grid
Definition: overlay_shader.c:200
OVERLAY_Shaders::edit_mesh_edge_flat
GPUShader * edit_mesh_edge_flat
Definition: overlay_shader.c:171
OVERLAY_Shaders::edit_mesh_skin_root
GPUShader * edit_mesh_skin_root
Definition: overlay_shader.c:174
OVERLAY_Shaders::edit_mesh_fnormals
GPUShader * edit_mesh_fnormals
Definition: overlay_shader.c:177
OVERLAY_Shaders::particle_dot
GPUShader * particle_dot
Definition: overlay_shader.c:216
OVERLAY_Shaders::edit_curve_point
GPUShader * edit_curve_point
Definition: overlay_shader.c:162
OVERLAY_Shaders::armature_shape_solid
GPUShader * armature_shape_solid
Definition: overlay_shader.c:152
OVERLAY_Shaders::volume_gridlines_flags_sh
GPUShader * volume_gridlines_flags_sh
Definition: overlay_shader.c:225
OVERLAY_Shaders::paint_weight
GPUShader * paint_weight
Definition: overlay_shader.c:214
OVERLAY_Shaders::paint_wire
GPUShader * paint_wire
Definition: overlay_shader.c:215
OVERLAY_Shaders::sculpt_mask
GPUShader * sculpt_mask
Definition: overlay_shader.c:219
OVERLAY_Shaders::edit_mesh_edge
GPUShader * edit_mesh_edge
Definition: overlay_shader.c:170
OVERLAY_Shaders::outline_prepass_gpencil
GPUShader * outline_prepass_gpencil
Definition: overlay_shader.c:206
OVERLAY_Shaders::edit_uv_tiled_image_borders
GPUShader * edit_uv_tiled_image_borders
Definition: overlay_shader.c:187
OVERLAY_Shaders::edit_gpencil_guide_point
GPUShader * edit_gpencil_guide_point
Definition: overlay_shader.c:164
OVERLAY_Shaders::uniform_color
GPUShader * uniform_color
Definition: overlay_shader.c:220
OVERLAY_Shaders::edit_mesh_facedot
GPUShader * edit_mesh_facedot
Definition: overlay_shader.c:173
OVERLAY_Shaders::edit_uv_edges
GPUShader * edit_uv_edges
Definition: overlay_shader.c:183
OVERLAY_Shaders::particle_shape
GPUShader * particle_shape
Definition: overlay_shader.c:217
OVERLAY_Shaders::antialiasing
GPUShader * antialiasing
Definition: overlay_shader.c:146
OVERLAY_Shaders::outline_prepass
GPUShader * outline_prepass
Definition: overlay_shader.c:205
OVERLAY_Shaders::armature_sphere_solid
GPUShader * armature_sphere_solid
Definition: overlay_shader.c:155
OVERLAY_Shaders::edit_gpencil_wire
GPUShader * edit_gpencil_wire
Definition: overlay_shader.c:166
OVERLAY_Shaders::armature_shape_wire
GPUShader * armature_shape_wire
Definition: overlay_shader.c:153
OVERLAY_Shaders::edit_lattice_point
GPUShader * edit_lattice_point
Definition: overlay_shader.c:167
OVERLAY_Shaders::extra_point
GPUShader * extra_point
Definition: overlay_shader.c:195
OVERLAY_Shaders::extra_loose_point
GPUShader * extra_loose_point
Definition: overlay_shader.c:197
OVERLAY_Shaders::extra_select
GPUShader * extra_select
Definition: overlay_shader.c:191
OVERLAY_Shaders::edit_lattice_wire
GPUShader * edit_lattice_wire
Definition: overlay_shader.c:168
OVERLAY_Shaders::armature_envelope_outline
GPUShader * armature_envelope_outline
Definition: overlay_shader.c:149
OVERLAY_Shaders::background
GPUShader * background
Definition: overlay_shader.c:158
OVERLAY_Shaders::extra_lightprobe_grid
GPUShader * extra_lightprobe_grid
Definition: overlay_shader.c:196
OVERLAY_Shaders::wireframe
GPUShader * wireframe[2]
Definition: overlay_shader.c:228
OVERLAY_Shaders::paint_texture
GPUShader * paint_texture
Definition: overlay_shader.c:212
OVERLAY_Shaders::edit_mesh_vert
GPUShader * edit_mesh_vert
Definition: overlay_shader.c:169
OVERLAY_Shaders::edit_mesh_analysis
GPUShader * edit_mesh_analysis
Definition: overlay_shader.c:178
OVERLAY_Shaders::extra_groundline
GPUShader * extra_groundline
Definition: overlay_shader.c:192
OVERLAY_Shaders::facing
GPUShader * facing
Definition: overlay_shader.c:198
OVERLAY_Shaders::edit_gpencil_point
GPUShader * edit_gpencil_point
Definition: overlay_shader.c:165
OVERLAY_Shaders::paint_point
GPUShader * paint_point
Definition: overlay_shader.c:211
OVERLAY_Shaders::armature_shape_outline
GPUShader * armature_shape_outline
Definition: overlay_shader.c:151
OVERLAY_Shaders::xray_fade
GPUShader * xray_fade
Definition: overlay_shader.c:229
OVERLAY_Shaders::volume_velocity_needle_sh
GPUShader * volume_velocity_needle_sh
Definition: overlay_shader.c:221
OVERLAY_Shaders::extra_wire
GPUShader * extra_wire[2]
Definition: overlay_shader.c:193
OVERLAY_Shaders::armature_stick
GPUShader * armature_stick
Definition: overlay_shader.c:156
OVERLAY_Shaders::outline_prepass_wire
GPUShader * outline_prepass_wire
Definition: overlay_shader.c:208
OVERLAY_Shaders::edit_uv_mask_image
GPUShader * edit_uv_mask_image
Definition: overlay_shader.c:189
OVERLAY_Shaders::pointcloud_dot
GPUShader * pointcloud_dot
Definition: overlay_shader.c:218
OVERLAY_Shaders::armature_dof_wire
GPUShader * armature_dof_wire
Definition: overlay_shader.c:147
OVERLAY_Shaders::armature_wire
GPUShader * armature_wire
Definition: overlay_shader.c:157
OVERLAY_Shaders::edit_particle_point
GPUShader * edit_particle_point
Definition: overlay_shader.c:180
OVERLAY_Shaders::volume_velocity_sh
GPUShader * volume_velocity_sh
Definition: overlay_shader.c:223
OVERLAY_Shaders::edit_mesh_vnormals
GPUShader * edit_mesh_vnormals
Definition: overlay_shader.c:175
OVERLAY_Shaders::edit_curve_wire
GPUShader * edit_curve_wire
Definition: overlay_shader.c:163
OVERLAY_Shaders::extra_wire_select
GPUShader * extra_wire_select
Definition: overlay_shader.c:194
OVERLAY_Shaders::armature_dof_solid
GPUShader * armature_dof_solid
Definition: overlay_shader.c:148
OVERLAY_Shaders::volume_gridlines_range_sh
GPUShader * volume_gridlines_range_sh
Definition: overlay_shader.c:226
OVERLAY_Shaders::gpencil_canvas
GPUShader * gpencil_canvas
Definition: overlay_shader.c:199
OVERLAY_Shaders::edit_uv_stretching_area
GPUShader * edit_uv_stretching_area
Definition: overlay_shader.c:186
OVERLAY_Shaders::armature_sphere_outline
GPUShader * armature_sphere_outline
Definition: overlay_shader.c:154
OVERLAY_Shaders::motion_path_line
GPUShader * motion_path_line
Definition: overlay_shader.c:203
OVERLAY_Shaders::extra
GPUShader * extra
Definition: overlay_shader.c:190
Generated on Tue Jan 31 2023 14:37:24 for Blender by  doxygen 1.9.1