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