Blender V4.3
overlay_next_shader.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
9#include "overlay_next_private.hh"
10
11namespace blender::draw::overlay {
12
13ShaderModule *ShaderModule::g_shader_modules[2][2] = {{nullptr}};
14
15ShaderModule::ShaderPtr ShaderModule::shader(
16 const char *create_info_name,
17 const FunctionRef<void(gpu::shader::ShaderCreateInfo &info)> patch)
18{
19 /* Perform a copy for patching. */
20 gpu::shader::ShaderCreateInfo info(create_info_name);
21 GPU_shader_create_info_get_unfinalized_copy(create_info_name,
22 reinterpret_cast<GPUShaderCreateInfo &>(info));
23
24 patch(info);
25
26 info.define("OVERLAY_NEXT");
27
28 if (clipping_enabled_) {
29 info.define("USE_WORLD_CLIP_PLANES");
30 }
31
32 return ShaderPtr(
33 GPU_shader_create_from_info(reinterpret_cast<const GPUShaderCreateInfo *>(&info)));
34}
35
36ShaderModule::ShaderPtr ShaderModule::selectable_shader(const char *create_info_name)
37{
38 /* TODO: This is what it should be like with all variations defined with create infos. */
39 // std::string create_info_name = base_create_info;
40 // create_info_name += SelectEngineT::shader_suffix;
41 // create_info_name += clipping_enabled_ ? "_clipped" : "";
42 // this->shader_ = GPU_shader_create_from_info_name(create_info_name.c_str());
43
44 /* WORKAROUND: ... but for now, we have to patch the create info used by the old engine. */
45
46 /* Perform a copy for patching. */
47 gpu::shader::ShaderCreateInfo info(create_info_name);
48 GPU_shader_create_info_get_unfinalized_copy(create_info_name,
49 reinterpret_cast<GPUShaderCreateInfo &>(info));
50
51 info.define("OVERLAY_NEXT");
52
53 if (selection_type_ != SelectionType::DISABLED) {
54 info.define("SELECT_ENABLE");
55 info.depth_write(gpu::shader::DepthWrite::UNCHANGED);
56 /* Replace additional info. */
57 for (StringRefNull &str : info.additional_infos_) {
58 if (str == "draw_modelmat_new") {
59 str = "draw_modelmat_new_with_custom_id";
60 }
61 }
62 info.additional_info("select_id_patch");
63 }
64
65 if (clipping_enabled_) {
66 info.define("USE_WORLD_CLIP_PLANES");
67 }
68
69 return ShaderPtr(
70 GPU_shader_create_from_info(reinterpret_cast<const GPUShaderCreateInfo *>(&info)));
71}
72
73ShaderModule::ShaderPtr ShaderModule::selectable_shader(
74 const char *create_info_name,
75 const FunctionRef<void(gpu::shader::ShaderCreateInfo &info)> patch)
76{
77 /* Perform a copy for patching. */
78 gpu::shader::ShaderCreateInfo info(create_info_name);
79 GPU_shader_create_info_get_unfinalized_copy(create_info_name,
80 reinterpret_cast<GPUShaderCreateInfo &>(info));
81
82 patch(info);
83
84 info.define("OVERLAY_NEXT");
85
86 if (selection_type_ != SelectionType::DISABLED) {
87 info.define("SELECT_ENABLE");
88 info.depth_write(gpu::shader::DepthWrite::UNCHANGED);
89 /* Replace additional info. */
90 for (StringRefNull &str : info.additional_infos_) {
91 if (str == "draw_modelmat_new") {
92 str = "draw_modelmat_new_with_custom_id";
93 }
94 }
95 info.additional_info("select_id_patch");
96 }
97
98 if (clipping_enabled_) {
99 info.define("USE_WORLD_CLIP_PLANES");
100 }
101
102 return ShaderPtr(
103 GPU_shader_create_from_info(reinterpret_cast<const GPUShaderCreateInfo *>(&info)));
104}
105
106using namespace blender::gpu::shader;
107
108static void shader_patch_common(gpu::shader::ShaderCreateInfo &info)
109{
110 info.additional_infos_.clear();
111 info.additional_info(
112 "draw_view", "draw_modelmat_new", "draw_resource_handle_new", "draw_globals");
113}
114
115static void shader_patch_edit_mesh_normal_common(gpu::shader::ShaderCreateInfo &info)
116{
117 shader_patch_common(info);
118 info.defines_.clear(); /* Removes WORKAROUND_INDEX_LOAD_INCLUDE. */
119 info.vertex_inputs_.clear();
120 info.additional_info("gpu_index_load");
121 info.storage_buf(1, Qualifier::READ, "float", "pos[]", Frequency::GEOMETRY);
122}
123
124ShaderModule::ShaderModule(const SelectionType selection_type, const bool clipping_enabled)
125 : selection_type_(selection_type), clipping_enabled_(clipping_enabled)
126{
129 attribute_viewer_mesh = shader(
130 "overlay_viewer_attribute_mesh", [](gpu::shader::ShaderCreateInfo &info) {
131 info.additional_infos_.clear();
132 info.additional_info("overlay_viewer_attribute_common", "draw_view", "draw_modelmat_new");
133 });
134 attribute_viewer_pointcloud = shader("overlay_viewer_attribute_pointcloud",
135 [](gpu::shader::ShaderCreateInfo &info) {
136 info.additional_infos_.clear();
137 info.additional_info("overlay_viewer_attribute_common",
138 "draw_pointcloud_new",
139 "draw_view",
140 "draw_modelmat_new");
141 });
142 attribute_viewer_curve = shader(
143 "overlay_viewer_attribute_curve", [](gpu::shader::ShaderCreateInfo &info) {
144 info.additional_infos_.clear();
145 info.additional_info("overlay_viewer_attribute_common", "draw_view", "draw_modelmat_new");
146 });
147 attribute_viewer_curves = shader(
148 "overlay_viewer_attribute_curves", [](gpu::shader::ShaderCreateInfo &info) {
149 info.additional_infos_.clear();
150 info.additional_info(
151 "overlay_viewer_attribute_common", "draw_hair_new", "draw_view", "draw_modelmat_new");
152 });
153
154 armature_degrees_of_freedom = shader(
155 "overlay_armature_dof", [](gpu::shader::ShaderCreateInfo &info) {
156 info.storage_buf(0, Qualifier::READ, "ExtraInstanceData", "data_buf[]");
157 info.define("inst_obmat", "data_buf[gl_InstanceID].object_to_world_");
158 info.define("color", "data_buf[gl_InstanceID].color_");
159 info.vertex_inputs_.pop_last();
160 info.vertex_inputs_.pop_last();
161 });
162
163 curve_edit_points = shader(
164 "overlay_edit_particle_point",
165 [](gpu::shader::ShaderCreateInfo &info) { shader_patch_common(info); });
166 curve_edit_line = shader("overlay_edit_particle_strand",
167 [](gpu::shader::ShaderCreateInfo &info) { shader_patch_common(info); });
168
169 extra_point = shader("overlay_extra_point", [](gpu::shader::ShaderCreateInfo &info) {
170 info.additional_infos_.clear();
171 info.vertex_inputs_.pop_last();
172 info.push_constants_.pop_last();
173 info.additional_info("draw_view", "draw_modelmat_new", "draw_globals")
174 .typedef_source("overlay_shader_shared.h")
175 .storage_buf(0, Qualifier::READ, "VertexData", "data_buf[]")
176 .define("pos", "data_buf[gl_VertexID].pos_.xyz")
177 .define("ucolor", "data_buf[gl_VertexID].color_");
178 });
179
180 grid_background = shader("overlay_grid_background", [](gpu::shader::ShaderCreateInfo &info) {
181 shader_patch_common(info);
182 info.push_constant(gpu::shader::Type::VEC3, "tile_scale");
183 info.define("tile_pos", "vec3(0.0)");
184 });
185
186 grid_image = shader("overlay_grid_image", [](gpu::shader::ShaderCreateInfo &info) {
187 shader_patch_common(info);
188 info.storage_buf(0, Qualifier::READ, "vec3", "tile_pos_buf[]")
189 .define("tile_pos", "tile_pos_buf[gl_InstanceID]")
190 .define("tile_scale", "vec3(1.0)");
191 ;
192 });
193
194 legacy_curve_edit_wires = shader(
195 "overlay_edit_curve_wire",
196 [](gpu::shader::ShaderCreateInfo &info) { shader_patch_common(info); });
197 legacy_curve_edit_points = shader(
198 "overlay_edit_curve_point",
199 [](gpu::shader::ShaderCreateInfo &info) { shader_patch_common(info); });
200
201 mesh_analysis = shader("overlay_edit_mesh_analysis",
202 [](gpu::shader::ShaderCreateInfo &info) { shader_patch_common(info); });
203
204 mesh_edit_face = shader("overlay_edit_mesh_face", [](gpu::shader::ShaderCreateInfo &info) {
205 shader_patch_common(info);
206 info.additional_info("overlay_edit_mesh_common");
207 });
208 mesh_edit_vert = shader("overlay_edit_mesh_vert", [](gpu::shader::ShaderCreateInfo &info) {
209 shader_patch_common(info);
210 info.additional_info("overlay_edit_mesh_common");
211 });
212
213 mesh_edit_depth = shader("overlay_edit_mesh_depth",
214 [](gpu::shader::ShaderCreateInfo &info) { shader_patch_common(info); });
215
216 mesh_edit_skin_root = shader(
217 "overlay_edit_mesh_skin_root", [](gpu::shader::ShaderCreateInfo &info) {
218 shader_patch_common(info);
219 /* TODO(fclem): Use correct vertex format. For now we read the format manually. */
220 info.storage_buf(0, Qualifier::READ, "float", "size[]", Frequency::GEOMETRY);
221 info.vertex_inputs_.clear();
222 info.define("VERTEX_PULL");
223 });
224
225 mesh_face_normal = shader("overlay_edit_mesh_normal", [](gpu::shader::ShaderCreateInfo &info) {
226 shader_patch_edit_mesh_normal_common(info);
227 info.define("FACE_NORMAL");
228 info.push_constant(gpu::shader::Type::BOOL, "hq_normals");
229 info.storage_buf(0, Qualifier::READ, "uint", "norAndFlag[]", Frequency::GEOMETRY);
230 });
231
232 mesh_face_normal_subdiv = shader(
233 "overlay_edit_mesh_normal", [](gpu::shader::ShaderCreateInfo &info) {
234 shader_patch_edit_mesh_normal_common(info);
235 info.define("FACE_NORMAL");
236 info.define("FLOAT_NORMAL");
237 info.storage_buf(0, Qualifier::READ, "vec4", "norAndFlag[]", Frequency::GEOMETRY);
238 });
239
240 mesh_loop_normal = shader("overlay_edit_mesh_normal", [](gpu::shader::ShaderCreateInfo &info) {
241 shader_patch_edit_mesh_normal_common(info);
242 info.define("LOOP_NORMAL");
243 info.push_constant(gpu::shader::Type::BOOL, "hq_normals");
244 info.storage_buf(0, Qualifier::READ, "uint", "lnor[]", Frequency::GEOMETRY);
245 });
246
247 mesh_loop_normal_subdiv = shader(
248 "overlay_edit_mesh_normal", [](gpu::shader::ShaderCreateInfo &info) {
249 shader_patch_edit_mesh_normal_common(info);
250 info.define("LOOP_NORMAL");
251 info.define("FLOAT_NORMAL");
252 info.storage_buf(0, Qualifier::READ, "vec4", "lnor[]", Frequency::GEOMETRY);
253 });
254
255 mesh_vert_normal = shader("overlay_edit_mesh_normal", [](gpu::shader::ShaderCreateInfo &info) {
256 shader_patch_edit_mesh_normal_common(info);
257 info.define("VERT_NORMAL");
258 info.storage_buf(0, Qualifier::READ, "uint", "vnor[]", Frequency::GEOMETRY);
259 });
260
261 outline_prepass_mesh = shader(
262 "overlay_outline_prepass_mesh", [](gpu::shader::ShaderCreateInfo &info) {
263 shader_patch_common(info);
264 info.additional_info("draw_object_infos_new", "overlay_outline_prepass");
265 });
266 outline_prepass_curves = shader(
267 "overlay_outline_prepass_curves", [](gpu::shader::ShaderCreateInfo &info) {
268 shader_patch_common(info);
269 info.additional_info("draw_hair_new", "draw_object_infos_new", "overlay_outline_prepass");
270 });
271 outline_prepass_pointcloud = shader(
272 "overlay_outline_prepass_pointcloud", [](gpu::shader::ShaderCreateInfo &info) {
273 shader_patch_common(info);
274 info.additional_info(
275 "draw_pointcloud_new", "draw_object_infos_new", "overlay_outline_prepass");
276 });
277 outline_prepass_gpencil = shader(
278 "overlay_outline_prepass_gpencil", [](gpu::shader::ShaderCreateInfo &info) {
279 shader_patch_common(info);
280 info.additional_info("draw_gpencil_new", "draw_object_infos_new");
281 });
282
283 particle_edit_vert = shader(
284 "overlay_edit_particle_point",
285 [](gpu::shader::ShaderCreateInfo &info) { shader_patch_common(info); });
286 particle_edit_edge = shader(
287 "overlay_edit_particle_strand",
288 [](gpu::shader::ShaderCreateInfo &info) { shader_patch_common(info); });
289
290 paint_region_edge = shader("overlay_paint_wire", [](gpu::shader::ShaderCreateInfo &info) {
291 shader_patch_common(info);
292 });
293 paint_region_face = shader("overlay_paint_face", [](gpu::shader::ShaderCreateInfo &info) {
294 shader_patch_common(info);
295 });
296 paint_region_vert = shader("overlay_paint_point", [](gpu::shader::ShaderCreateInfo &info) {
297 shader_patch_common(info);
298 });
299 paint_texture = shader("overlay_paint_texture",
300 [](gpu::shader::ShaderCreateInfo &info) { shader_patch_common(info); });
301 paint_weight = shader("overlay_paint_weight",
302 [](gpu::shader::ShaderCreateInfo &info) { shader_patch_common(info); });
303 paint_weight_fake_shading = shader("overlay_paint_weight",
304 [](gpu::shader::ShaderCreateInfo &info) {
305 shader_patch_common(info);
306 info.define("FAKE_SHADING");
307 info.push_constant(gpu::shader::Type::VEC3, "light_dir");
308 });
309
310 sculpt_mesh = shader("overlay_sculpt_mask",
311 [](gpu::shader::ShaderCreateInfo &info) { shader_patch_common(info); });
312 sculpt_curves = shader("overlay_sculpt_curves_selection",
313 [](gpu::shader::ShaderCreateInfo &info) {
314 shader_patch_common(info);
315 info.additional_info("draw_hair_new");
316 });
317 sculpt_curves_cage = shader(
318 "overlay_sculpt_curves_cage",
319 [](gpu::shader::ShaderCreateInfo &info) { shader_patch_common(info); });
320
321 uv_analysis_stretch_angle = shader("overlay_edit_uv_stretching_angle",
322 [](gpu::shader::ShaderCreateInfo &info) {
323 shader_patch_common(info);
324 info.additional_info("overlay_edit_uv_stretching");
325 });
326 uv_analysis_stretch_area = shader("overlay_edit_uv_stretching_area",
327 [](gpu::shader::ShaderCreateInfo &info) {
328 shader_patch_common(info);
329 info.additional_info("overlay_edit_uv_stretching");
330 });
331 uv_edit_vert = shader("overlay_edit_uv_verts",
332 [](gpu::shader::ShaderCreateInfo &info) { shader_patch_common(info); });
333 uv_edit_face = shader("overlay_edit_uv_faces",
334 [](gpu::shader::ShaderCreateInfo &info) { shader_patch_common(info); });
335 uv_edit_facedot = shader("overlay_edit_uv_face_dots",
336 [](gpu::shader::ShaderCreateInfo &info) { shader_patch_common(info); });
337 uv_image_borders = shader("overlay_edit_uv_tiled_image_borders",
338 [](gpu::shader::ShaderCreateInfo &info) {
339 info.additional_infos_.clear();
340 info.push_constant(gpu::shader::Type::VEC3, "tile_pos");
341 info.define("tile_scale", "vec3(1.0)");
342 info.additional_info("draw_view");
343 });
344 uv_brush_stencil = shader("overlay_edit_uv_stencil_image",
345 [](gpu::shader::ShaderCreateInfo &info) {
346 info.additional_infos_.clear();
347 info.push_constant(gpu::shader::Type::VEC2, "brush_offset");
348 info.push_constant(gpu::shader::Type::VEC2, "brush_scale");
349 info.additional_info("draw_view");
350 });
351 uv_paint_mask = shader("overlay_edit_uv_mask_image", [](gpu::shader::ShaderCreateInfo &info) {
352 info.additional_infos_.clear();
353 info.push_constant(gpu::shader::Type::VEC2, "brush_offset");
354 info.push_constant(gpu::shader::Type::VEC2, "brush_scale");
355 info.additional_info("draw_view");
356 });
357
358 xray_fade = shader("overlay_xray_fade", [](gpu::shader::ShaderCreateInfo &info) {
359 info.sampler(2, ImageType::DEPTH_2D, "xrayDepthTexInfront");
360 });
361
364 armature_envelope_fill = selectable_shader(
365 "overlay_armature_envelope_solid", [](gpu::shader::ShaderCreateInfo &info) {
366 info.storage_buf(0, Qualifier::READ, "BoneEnvelopeData", "data_buf[]");
367 info.define("headSphere", "data_buf[gl_InstanceID].head_sphere");
368 info.define("tailSphere", "data_buf[gl_InstanceID].tail_sphere");
369 info.define("xAxis", "data_buf[gl_InstanceID].x_axis.xyz");
370 info.define("stateColor", "data_buf[gl_InstanceID].state_color.xyz");
371 info.define("boneColor", "data_buf[gl_InstanceID].bone_color_and_wire_width.xyz");
372 info.vertex_inputs_.pop_last();
373 info.vertex_inputs_.pop_last();
374 info.vertex_inputs_.pop_last();
375 info.vertex_inputs_.pop_last();
376 info.vertex_inputs_.pop_last();
377 });
378
379 armature_envelope_outline = selectable_shader(
380 "overlay_armature_envelope_outline", [](gpu::shader::ShaderCreateInfo &info) {
381 info.storage_buf(0, Qualifier::READ, "BoneEnvelopeData", "data_buf[]");
382 info.define("headSphere", "data_buf[gl_InstanceID].head_sphere");
383 info.define("tailSphere", "data_buf[gl_InstanceID].tail_sphere");
384 info.define("outlineColorSize", "data_buf[gl_InstanceID].bone_color_and_wire_width");
385 info.define("xAxis", "data_buf[gl_InstanceID].x_axis.xyz");
386 info.vertex_inputs_.pop_last();
387 info.vertex_inputs_.pop_last();
388 info.vertex_inputs_.pop_last();
389 info.vertex_inputs_.pop_last();
390 });
391
392 armature_shape_outline = selectable_shader("overlay_armature_shape_outline_next",
393 [](gpu::shader::ShaderCreateInfo & /*info*/) {});
394
395 armature_shape_fill = selectable_shader(
396 "overlay_armature_shape_solid", [](gpu::shader::ShaderCreateInfo &info) {
397 info.storage_buf(0, Qualifier::READ, "mat4", "data_buf[]");
398 info.define("inst_obmat", "data_buf[gl_InstanceID]");
399 info.vertex_inputs_.pop_last();
400 });
401
402 armature_shape_wire = selectable_shader("overlay_armature_shape_wire_next",
403 [](gpu::shader::ShaderCreateInfo & /*info*/) {});
404
405 armature_sphere_outline = selectable_shader(
406 "overlay_armature_sphere_outline", [](gpu::shader::ShaderCreateInfo &info) {
407 info.storage_buf(0, Qualifier::READ, "mat4", "data_buf[]");
408 info.define("inst_obmat", "data_buf[gl_InstanceID]");
409 info.vertex_inputs_.pop_last();
410 });
411 armature_sphere_fill = selectable_shader(
412 "overlay_armature_sphere_solid", [](gpu::shader::ShaderCreateInfo &info) {
413 info.storage_buf(0, Qualifier::READ, "mat4", "data_buf[]");
414 info.define("inst_obmat", "data_buf[gl_InstanceID]");
415 info.vertex_inputs_.pop_last();
416 });
417
418 armature_stick = selectable_shader(
419 "overlay_armature_stick", [](gpu::shader::ShaderCreateInfo &info) {
420 info.additional_infos_.clear();
421 info.additional_info("overlay_frag_output",
422 "overlay_armature_common",
423 "draw_resource_handle_new",
424 "draw_modelmat_new",
425 "draw_globals");
426 info.storage_buf(0, Qualifier::READ, "BoneStickData", "data_buf[]");
427 info.define("boneStart", "data_buf[gl_InstanceID].bone_start.xyz");
428 info.define("boneEnd", "data_buf[gl_InstanceID].bone_end.xyz");
429 info.define("wireColor", "data_buf[gl_InstanceID].wire_color");
430 info.define("boneColor", "data_buf[gl_InstanceID].bone_color");
431 info.define("headColor", "data_buf[gl_InstanceID].head_color");
432 info.define("tailColor", "data_buf[gl_InstanceID].tail_color");
433 info.vertex_inputs_.pop_last();
434 info.vertex_inputs_.pop_last();
435 info.vertex_inputs_.pop_last();
436 info.vertex_inputs_.pop_last();
437 info.vertex_inputs_.pop_last();
438 info.vertex_inputs_.pop_last();
439 info.vertex_inputs_.pop_last();
440 info.vertex_in(1, gpu::shader::Type::INT, "vclass");
441 info.define("flag", "vclass");
442 });
443
444 armature_wire = selectable_shader(
445 "overlay_armature_wire", [](gpu::shader::ShaderCreateInfo &info) {
446 info.additional_infos_.clear();
447 info.additional_info("draw_view",
448 "overlay_frag_output",
449 "draw_resource_handle_new",
450 "draw_modelmat_new",
451 "draw_globals");
452 info.storage_buf(0, Qualifier::READ, "VertexData", "data_buf[]");
453 info.define("pos", "data_buf[gl_VertexID].pos_.xyz");
454 info.define("color", "data_buf[gl_VertexID].color_");
455 info.vertex_inputs_.pop_last();
456 info.vertex_inputs_.pop_last();
457 });
458
459 facing = shader("overlay_facing", [](gpu::shader::ShaderCreateInfo &info) {
460 info.additional_infos_.clear();
461 info.additional_info(
462 "draw_view", "draw_modelmat_new", "draw_resource_handle_new", "draw_globals");
463 });
464
465 fluid_grid_lines_flags = selectable_shader(
466 "overlay_volume_gridlines_flags", [](gpu::shader::ShaderCreateInfo &info) {
467 info.additional_infos_.clear();
468 info.additional_info("draw_volume_new", "draw_view", "overlay_volume_gridlines");
469 });
470
471 fluid_grid_lines_flat = selectable_shader(
472 "overlay_volume_gridlines_flat", [](gpu::shader::ShaderCreateInfo &info) {
473 info.additional_infos_.clear();
474 info.additional_info("draw_volume_new", "draw_view", "overlay_volume_gridlines");
475 });
476
477 fluid_grid_lines_range = selectable_shader(
478 "overlay_volume_gridlines_range", [](gpu::shader::ShaderCreateInfo &info) {
479 info.additional_infos_.clear();
480 info.additional_info("draw_volume_new", "draw_view", "overlay_volume_gridlines");
481 });
482
483 fluid_velocity_streamline = selectable_shader(
484 "overlay_volume_velocity_streamline", [](gpu::shader::ShaderCreateInfo &info) {
485 info.additional_infos_.clear();
486 info.additional_info("draw_volume_new", "draw_view", "overlay_volume_velocity");
487 });
488
489 fluid_velocity_mac = selectable_shader(
490 "overlay_volume_velocity_mac", [](gpu::shader::ShaderCreateInfo &info) {
491 info.additional_infos_.clear();
492 info.additional_info("draw_volume_new", "draw_view", "overlay_volume_velocity");
493 });
494
495 fluid_velocity_needle = selectable_shader(
496 "overlay_volume_velocity_needle", [](gpu::shader::ShaderCreateInfo &info) {
497 info.additional_infos_.clear();
498 info.additional_info("draw_volume_new", "draw_view", "overlay_volume_velocity");
499 });
500
501 extra_shape = selectable_shader("overlay_extra", [](gpu::shader::ShaderCreateInfo &info) {
502 info.storage_buf(0, Qualifier::READ, "ExtraInstanceData", "data_buf[]");
503 info.define("color", "data_buf[gl_InstanceID].color_");
504 info.define("inst_obmat", "data_buf[gl_InstanceID].object_to_world_");
505 info.vertex_inputs_.pop_last();
506 info.vertex_inputs_.pop_last();
507 });
508
509 extra_wire = selectable_shader("overlay_extra_wire", [](gpu::shader::ShaderCreateInfo &info) {
510 info.typedef_source("overlay_shader_shared.h");
511 info.storage_buf(0, Qualifier::READ, "VertexData", "data_buf[]");
512 info.push_constant(gpu::shader::Type::INT, "colorid");
513 info.define("pos", "data_buf[gl_VertexID].pos_.xyz");
514 info.define("color", "data_buf[gl_VertexID].color_");
515 info.additional_infos_.clear();
516 info.additional_info(
517 "draw_view", "draw_modelmat_new", "draw_resource_handle_new", "draw_globals");
518 info.vertex_inputs_.pop_last();
519 info.vertex_inputs_.pop_last();
520 info.vertex_inputs_.pop_last();
521 });
522
523 extra_wire_object = selectable_shader(
524 "overlay_extra_wire", [](gpu::shader::ShaderCreateInfo &info) {
525 info.define("OBJECT_WIRE");
526 info.additional_infos_.clear();
527 info.additional_info(
528 "draw_view", "draw_modelmat_new", "draw_resource_handle_new", "draw_globals");
529 });
530
531 extra_loose_points = selectable_shader(
532 "overlay_extra_loose_point", [](gpu::shader::ShaderCreateInfo &info) {
533 info.typedef_source("overlay_shader_shared.h");
534 info.storage_buf(0, Qualifier::READ, "VertexData", "data_buf[]");
535 info.define("pos", "data_buf[gl_VertexID].pos_.xyz");
536 info.define("vertex_color", "data_buf[gl_VertexID].color_");
537 info.vertex_inputs_.pop_last();
538 info.vertex_inputs_.pop_last();
539 info.additional_infos_.clear();
540 info.additional_info("draw_view", "draw_modelmat_new", "draw_globals");
541 });
542
543 lattice_points = selectable_shader(
544 "overlay_edit_lattice_point", [](gpu::shader::ShaderCreateInfo &info) {
545 info.additional_infos_.clear();
546 info.additional_info(
547 "draw_view", "draw_modelmat_new", "draw_resource_handle_new", "draw_globals");
548 });
549
550 lattice_wire = selectable_shader(
551 "overlay_edit_lattice_wire", [](gpu::shader::ShaderCreateInfo &info) {
552 info.additional_infos_.clear();
553 info.additional_info(
554 "draw_view", "draw_modelmat_new", "draw_resource_handle_new", "draw_globals");
555 });
556
557 extra_grid = selectable_shader("overlay_extra_grid", [](gpu::shader::ShaderCreateInfo &info) {
558 info.additional_infos_.clear();
559 info.additional_info(
560 "draw_view", "draw_modelmat_new", "draw_resource_handle_new", "draw_globals");
561 });
562
563 extra_ground_line = selectable_shader(
564 "overlay_extra_groundline", [](gpu::shader::ShaderCreateInfo &info) {
565 info.storage_buf(0, Qualifier::READ, "vec4", "data_buf[]");
566 info.define("inst_pos", "data_buf[gl_InstanceID].xyz");
567 info.vertex_inputs_.pop_last();
568 });
569
570 image_plane = selectable_shader("overlay_image", [](gpu::shader::ShaderCreateInfo &info) {
571 info.additional_infos_.clear();
572 info.additional_info(
573 "draw_view", "draw_globals", "draw_modelmat_new", "draw_resource_handle_new");
574 });
575
576 particle_dot = selectable_shader("overlay_particle_dot",
577 [](gpu::shader::ShaderCreateInfo &info) {
578 info.additional_infos_.clear();
579 info.additional_info("overlay_particle",
580 "draw_view",
581 "draw_modelmat_new",
582 "draw_resource_handle_new",
583 "draw_globals");
584 });
585
586 particle_shape = selectable_shader("overlay_particle_shape_next",
587 [](gpu::shader::ShaderCreateInfo & /*info*/) {});
588
589 particle_hair = selectable_shader("overlay_particle_hair_next",
590 [](gpu::shader::ShaderCreateInfo & /*info*/) {});
591
592 uniform_color = shader("overlay_uniform_color", [](gpu::shader::ShaderCreateInfo &info) {
593 info.additional_infos_.clear();
594 info.additional_info(
595 "draw_view", "draw_modelmat_new", "draw_resource_handle_new", "draw_globals");
596 });
597
598 uniform_color_batch = shader("overlay_uniform_color", [](gpu::shader::ShaderCreateInfo &info) {
599 info.additional_infos_.clear();
600 info.additional_info("draw_view", "draw_globals")
601 .typedef_source("draw_shader_shared.hh")
602 .storage_buf(0, Qualifier::READ, "ObjectMatrices", "matrix_buf[]")
603 .define("DRAW_MODELMAT_CREATE_INFO")
604 .define("drw_ModelMatrixInverse", "matrix_buf[gl_InstanceID].model_inverse")
605 .define("drw_ModelMatrix", "matrix_buf[gl_InstanceID].model")
606 /* TODO For compatibility with old shaders. To be removed. */
607 .define("ModelMatrixInverse", "drw_ModelMatrixInverse")
608 .define("ModelMatrix", "drw_ModelMatrix");
609 });
610
611 wireframe_mesh = selectable_shader("overlay_wireframe", [](gpu::shader::ShaderCreateInfo &info) {
612 info.additional_infos_.clear();
613 info.define("CUSTOM_DEPTH_BIAS_CONST");
614 info.specialization_constant(gpu::shader::Type::BOOL, "use_custom_depth_bias", true);
615 info.additional_info("draw_view",
616 "draw_modelmat_new",
617 "draw_resource_handle_new",
618 "draw_object_infos_new",
619 "draw_globals");
620 });
621
622 wireframe_points = selectable_shader("overlay_wireframe_points",
623 [](gpu::shader::ShaderCreateInfo & /*info*/) {});
624
625 wireframe_curve = selectable_shader("overlay_wireframe_curve",
626 [](gpu::shader::ShaderCreateInfo & /*info*/) {});
627}
628
629ShaderModule &ShaderModule::module_get(SelectionType selection_type, bool clipping_enabled)
630{
631 int selection_index = selection_type == SelectionType::DISABLED ? 0 : 1;
632 ShaderModule *&g_shader_module = g_shader_modules[selection_index][clipping_enabled];
633 if (g_shader_module == nullptr) {
634 /* TODO(@fclem) thread-safety. */
635 g_shader_module = new ShaderModule(selection_type, clipping_enabled);
636 }
637 return *g_shader_module;
638}
639
640void ShaderModule::module_free()
641{
642 for (int i : IndexRange(2)) {
643 for (int j : IndexRange(2)) {
644 if (g_shader_modules[i][j] != nullptr) {
645 /* TODO(@fclem) thread-safety. */
646 delete g_shader_modules[i][j];
647 g_shader_modules[i][j] = nullptr;
648 }
649 }
650 }
651}
652
653} // namespace blender::draw::overlay
GPU_shader_create_from_info
GPUShader * GPU_shader_create_from_info(const GPUShaderCreateInfo *_info)
Definition gpu_shader.cc:295
GPU_shader_create_info_get_unfinalized_copy
void GPU_shader_create_info_get_unfinalized_copy(const char *info_name, GPUShaderCreateInfo &r_info)
Definition gpu_shader.cc:264
blender::draw::overlay::ShaderModule::ShaderModule
ShaderModule(const SelectionType selection_type, const bool clipping_enabled)
Definition overlay_next_shader.cc:124
blender::eevee::ShaderModule::module_get
static ShaderModule * module_get()
Definition eevee_shader.cc:32
typedef_source
input_tx typedef_source("gpu_shader_compositor_type_conversion.glsl") .compute_source("compositor_convert.glsl")
define
output_img define("CONVERT_EXPRESSION(value)", "value") .do_static_compilation(true)
storage_buf
DOF_REDUCE_GROUP_SIZE dof_buf scatter_fg_list_buf[] storage_buf(1, Qualifier::WRITE, "ScatterRect", "scatter_bg_list_buf[]") .storage_buf(2
str
#define str(s)
Definition ffmpeg_codecs.cc:103
blender::draw::overlay::shader_patch_common
static void shader_patch_common(gpu::shader::ShaderCreateInfo &info)
Definition overlay_next_shader.cc:108
blender::draw::overlay::shader_patch_edit_mesh_normal_common
static void shader_patch_edit_mesh_normal_common(gpu::shader::ShaderCreateInfo &info)
Definition overlay_next_shader.cc:115
overlay_next_private.hh
blender::gpu::shader::ShaderCreateInfo
Describe inputs & outputs, stage interfaces, resources and sources of a shader. If all data is correc...
Definition gpu_shader_create_info.hh:362
blender::gpu::shader::ShaderCreateInfo::defines_
Vector< std::array< StringRefNull, 2 > > defines_
Definition gpu_shader_create_info.hh:609
blender::gpu::shader::ShaderCreateInfo::vertex_in
Self & vertex_in(int slot, Type type, StringRefNull name)
Definition gpu_shader_create_info.hh:635
blender::gpu::shader::ShaderCreateInfo::push_constant
Self & push_constant(Type type, StringRefNull name, int array_size=0)
Definition gpu_shader_create_info.hh:883
blender::gpu::shader::ShaderCreateInfo::additional_info
Self & additional_info(StringRefNull info_name)
Definition gpu_shader_create_info.hh:958
blender::gpu::shader::ShaderCreateInfo::typedef_source
Self & typedef_source(StringRefNull filename)
Definition gpu_shader_create_info.hh:981
blender::gpu::shader::ShaderCreateInfo::storage_buf
Self & storage_buf(int slot, Qualifier qualifiers, StringRefNull type_name, StringRefNull name, Frequency freq=Frequency::PASS)
Definition gpu_shader_create_info.hh:796
blender::gpu::shader::ShaderCreateInfo::sampler
Self & sampler(int slot, ImageType type, StringRefNull name, Frequency freq=Frequency::PASS, GPUSamplerState sampler=GPUSamplerState::internal_sampler())
Definition gpu_shader_create_info.hh:828
blender::gpu::shader::ShaderCreateInfo::specialization_constant
Self & specialization_constant(Type type, StringRefNull name, double default_value)
Definition gpu_shader_create_info.hh:748
blender::gpu::shader::ShaderCreateInfo::define
Self & define(StringRefNull name, StringRefNull value="")
Definition gpu_shader_create_info.hh:901
Generated on Thu Feb 6 2025 07:36:39 for Blender by  doxygen 1.11.0