Blender V5.3
overlay_gsplat.bsl.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2026 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
14
15#pragma once
16
17#include "draw_view_infos.hh" // IWYU pragma: export
18
23
25#include "draw_model.bsl.hh"
27#include "draw_view.bsl.hh"
28
29#include "select_lib.bsl.hh"
30
31#include "overlay_common.bsl.hh"
33
34namespace overlay {
35
39
41
47struct VertOut {
49 [[flat]] float alpha;
51};
56
58 [[resource_table]] const Resources &srt,
59 [[resource_table]] const Clipping &clip,
61 [[resource_table]] const draw::Model &models,
62 [[resource_table]] const draw::Infos & /* infos */,
63 [[resource_table]] const draw::View &views,
64 [[resource_table]] const draw::Resource &res_id,
65 [[vertex_id]] const int vert_id,
66 [[instance_index]] const int inst_index,
67 [[position]] float4 &out_position,
68 [[clip_distance, condition(use_clipping)]] float (&clip_distances)[6],
69 [[out]] VertOut &v_out)
70{
71 draw::ID id = res_id.get(inst_index);
72 uint view_id = 0;
73 uint resource_id = id.resource_id<1>();
74
75 const ViewMatrices view = views.get(view_id);
76 const ObjectMatrices obj = models.get(resource_id);
77
78 const draw::gsplat::SplatShape gs = shape.get_splat(uint(vert_id), obj, view);
79 if (gs.is_culled()) {
80 out_position = float4(NAN_FLT);
81 return;
82 }
83
84 /* Output splat billboard as position. */
85 out_position = gs.hP;
86
87 v_out.P = gs.shape_offset;
88 v_out.alpha = shape.get_opacity(gs.id);
89 v_out.final_color = draw::pointcloud::get_customdata_vec4(int(gs.id), srt.attribute_tx);
90
91 if (clip.constants.use_clipping) [[static_branch]] {
92 clip.set_clipping_distances(gs.wP,
93 clip_distances[0],
94 clip_distances[1],
95 clip_distances[2],
96 clip_distances[3],
97 clip_distances[4],
98 clip_distances[5]);
99 }
100}
101
102[[fragment]] void frag([[resource_table]] const Resources &srt,
103 [[in]] const VertOut &v_in,
104 [[out]] FragOut &f_out)
105{
106 /* Discard outline parts below a threshold. Otherwise, the gsplat outline shows billboards. */
107 float alpha = draw::gsplat::evaluate_gaussian(v_in.P, v_in.alpha);
108 if (alpha < 0.1f) {
110 }
111
112 f_out.color = v_in.final_color * srt.opacity;
113 f_out.line = float4(0.0f);
114}
115
116} // namespace viewer_attribute
117
118namespace wireframe {
119
138
139namespace detail {
140
142{
143 float3 nrgb = abs(hsv.x * 6.0f - float3(3.0f, 2.0f, 4.0f)) * float3(1, -1, -1) +
144 float3(-1, 2, 2);
145 nrgb = clamp(nrgb, 0.0f, 1.0f);
146 return ((nrgb - 1.0f) * hsv.y + 1.0f) * hsv.z;
147}
148
149void wire_color_get(float3 &rim_col,
150 float3 &wire_col,
151 const ObjectInfos &ob_infos,
152 [[resource_table]] const Resources &srt)
153{
154 bool is_selected = flag_test(ob_infos.flag, OBJECT_SELECTED);
155 bool is_from_set = flag_test(ob_infos.flag, OBJECT_FROM_SET);
156 bool is_active = flag_test(ob_infos.flag, OBJECT_ACTIVE);
157
158 if (is_from_set) {
159 rim_col = srt.uniform_buf.colors.wire.rgb;
160 wire_col = srt.uniform_buf.colors.wire.rgb;
161 }
162 else if (is_selected && srt.use_coloring) {
163 if (srt.is_transform) {
164 rim_col = srt.uniform_buf.colors.transform.rgb;
165 }
166 else if (is_active) {
167 rim_col = srt.uniform_buf.colors.active_object.rgb;
168 }
169 else {
170 rim_col = srt.uniform_buf.colors.object_select.rgb;
171 }
172 wire_col = srt.uniform_buf.colors.wire.rgb;
173 }
174 else {
175 rim_col = srt.uniform_buf.colors.wire.rgb;
176 wire_col = srt.uniform_buf.colors.background.rgb;
177 }
178}
179
181 float3 &wire_col,
182 const ObjectInfos &ob_infos,
183 [[resource_table]] const Resources &srt)
184{
185 if (srt.color_type == V3D_SHADING_OBJECT_COLOR) {
186 rim_col = wire_col = ob_infos.ob_color.rgb * 0.5f;
187 }
188 else {
189 float3 hsv = float3(ob_infos.random, 0.75f, 0.8f);
190 rim_col = wire_col = hsv_to_rgb(hsv);
191 }
192
193 if (flag_test(ob_infos.flag, OBJECT_SELECTED) && srt.use_coloring) {
194 wire_col += 1e-4f; /* Avoid division by 0. */
195 float brightness = max(wire_col.x, max(wire_col.y, wire_col.z));
196 wire_col *= 0.5f / brightness;
197 rim_col += 0.75f;
198 }
199 else {
200 rim_col *= 0.5f;
201 wire_col += 0.5f;
202 }
203}
204
205} // namespace detail
206
208 [[resource_table]] const Resources &srt,
210 [[resource_table]] const draw::Model &models,
211 [[resource_table]] const draw::Infos &infos,
212 [[resource_table]] const draw::View &views,
213 [[resource_table, condition(selectable)]] const draw::Select & /* select */,
214 [[resource_table, condition(!selectable)]] const draw::Resource &res_id,
216 condition(selectable)]] const draw::ResourceCustomID &custom_id,
217 [[vertex_id]] const int vert_id,
218 [[instance_index]] const int inst_index,
219 [[position]] float4 &out_position,
220 [[point_size]] float &out_pointsize,
221 [[resource_table]] const Clipping &clip,
222 [[clip_distance, condition(use_clipping)]] float (&clip_distances)[6],
223 [[out]] VertOut &v_out)
224{
225 draw::ID id;
226 if (pipe.selectable) [[static_branch]] {
227 v_out.select_id = custom_id.get_custom_id(inst_index);
228 id = custom_id.get(inst_index);
229 }
230 else {
231 id = res_id.get(inst_index);
232 }
233 uint view_id = 0;
234 uint resource_id = id.resource_id<1>();
235
236 const ViewMatrices view = views.get(view_id);
237 const ObjectMatrices obj = models.get(resource_id);
238 const ObjectInfos ob_infos = infos.get(resource_id);
239
240 const draw::gsplat::PointShape gs = shape.get_point(uint(vert_id), obj, view);
241 if (gs.is_culled()) {
242 out_position = float4(NAN_FLT);
243 return;
244 }
245
246 out_position = gs.hP;
247 out_pointsize = srt.uniform_buf.sizes.vert * 2.0f;
248 out_position.z -= srt.ndc_offset_factor * 0.5f;
249
250 /* Get wire object color */
251 float3 rim_col;
252 float3 wire_col;
253 if (srt.color_type == V3D_SHADING_OBJECT_COLOR || srt.color_type == V3D_SHADING_RANDOM_COLOR) {
254 detail::wire_object_color_get(rim_col, wire_col, ob_infos, srt);
255 }
256 else {
257 detail::wire_color_get(rim_col, wire_col, ob_infos, srt);
258 }
259
260 v_out.final_color = float4(wire_col * srt.wire_opacity, srt.wire_opacity);
261 v_out.final_color_inner = float4(rim_col * srt.wire_opacity, srt.wire_opacity);
262
263 if (clip.constants.use_clipping) [[static_branch]] {
264 clip.set_clipping_distances(gs.wP,
265 clip_distances[0],
266 clip_distances[1],
267 clip_distances[2],
268 clip_distances[3],
269 clip_distances[4],
270 clip_distances[5]);
271 }
272}
273
275 [[resource_table]] const Resources & /* srt */,
277 [[point_coord]] const float2 &in_pointcoord,
278 [[frag_coord]] const float4 frag_coordinate,
279 [[in]] const VertOut &v_in,
280 [[out]] FragOut &f_out)
281{
282 float2 centered = abs(in_pointcoord - float2(0.5f));
283 float dist = max(centered.x, centered.y);
284
285 /* Create a small gradient so that dense objects have a small fresnel effect. */
286 /* Non linear blend. */
287 float fac = dist * dist * 4.0f;
288 float3 rim_col = sqrt(v_in.final_color_inner.rgb);
289 float3 wire_col = sqrt(v_in.final_color.rgb);
290 float3 final_front_col = mix(rim_col, wire_col, 0.35f);
291 float3 color = mix(final_front_col, rim_col, saturate(fac));
292
293 f_out.color = float4(color * color, v_in.final_color.a);
294 f_out.line = float4(0.0f);
295
296 if (pipe.selectable) [[static_branch]] {
297 select.select_id_output(v_in.select_id, frag_coordinate);
298 }
299}
300
301} // namespace wireframe
302
303namespace edit_vert {
304
308struct VertOut {
310};
315
317 [[resource_table]] const Resources &srt,
319 [[resource_table]] const draw::Resource &res_id,
320 [[resource_table]] const draw::Model &models,
321 [[resource_table]] const draw::View &views,
322 [[vertex_id]] const int vert_id,
323 [[instance_index]] const int inst_index,
324 [[position]] float4 &out_position,
325 [[point_size]] float &out_pointsize,
326 [[resource_table]] const Clipping &clip,
327 [[clip_distance, condition(use_clipping)]] float (&clip_distances)[6],
328 [[out]] VertOut &v_out)
329{
330 draw::ID id = res_id.get(inst_index);
331 uint view_id = 0;
332 uint resource_id = id.resource_id<1>();
333
334 const ObjectMatrices obj = models.get(resource_id);
335 const ViewMatrices view = views.get(view_id);
336
337 const draw::gsplat::PointShape gs = shape.get_point(uint(vert_id), obj, view);
338 if (gs.is_culled()) {
339 out_position = float4(NAN_FLT);
340 return;
341 }
342
343 /* NOTE: could just offset homogeneous z by a tiny bit instead? */
344 float3 wP = gs.wP;
345 float3 wV = view.world_incident_vector(wP);
346 wP += wV * 1e-2f;
347
348 /* Add small offset to z-position for depth precision. */
349 out_position = view.point_world_to_homogenous(wP);
350 out_position.z -= 3e-4f;
351 out_pointsize = srt.uniform_buf.sizes.vert * 2.0f;
352
353 v_out.final_color = srt.uniform_buf.colors.vert_select;
354
355 if (clip.constants.use_clipping) [[static_branch]] {
356 clip.set_clipping_distances(wP,
357 clip_distances[0],
358 clip_distances[1],
359 clip_distances[2],
360 clip_distances[3],
361 clip_distances[4],
362 clip_distances[5]);
363 }
364}
365
366[[fragment]] void frag([[point_coord]] const float2 &in_pointcoord,
367 [[in]] const VertOut &v_in,
368 [[out]] FragOut &f_out)
369{
370 /* Round point with jagged edges. */
371 float dist_squared = distance_squared(in_pointcoord, float2(0.5f));
372 constexpr float dist_threshold = 0.25f;
373 if (dist_squared > dist_threshold) {
375 return;
376 }
377
378 f_out.color = v_in.final_color;
379 f_out.line = float4(0.0f);
380}
381
382} // namespace edit_vert
383
384namespace depth_only {
385
389struct VertOut {
390 [[flat]] uint select_id;
391 [[flat]] float alpha;
393};
394
396 [[resource_table]] const Resources & /* srt */,
398 [[resource_table]] const draw::View &views,
399 [[resource_table]] const draw::Model &models,
400 [[resource_table, condition(selectable)]] const draw::Select & /* select */,
401 [[resource_table, condition(!selectable)]] const draw::Resource &res_id,
403 condition(selectable)]] const draw::ResourceCustomID &custom_id,
404 [[vertex_id]] const int vert_id,
405 [[instance_index]] const int inst_index,
406 [[position]] float4 &out_position,
407 [[resource_table]] const Clipping &clip,
408 [[clip_distance, condition(use_clipping)]] float (&clip_distances)[6],
409 [[out]] VertOut &v_out)
410{
411 draw::ID id;
412 if (pipe.selectable) [[static_branch]] {
413 v_out.select_id = custom_id.get_custom_id(inst_index);
414 id = custom_id.get(inst_index);
415 }
416 else {
417 v_out.select_id = 0u;
418 id = res_id.get(inst_index);
419 }
420 uint view_id = 0;
421 uint resource_id = id.resource_id<1>();
422
423 const ViewMatrices view = views.get(view_id);
424 const ObjectMatrices obj = models.get(resource_id);
425
426 const draw::gsplat::SplatShape gs = shape.get_splat(uint(vert_id), obj, view);
427 if (gs.is_culled()) {
428 out_position = float4(NAN_FLT);
429 return;
430 }
431
432 /* Output splat billboard as position. */
433 v_out.P = gs.shape_offset;
434 v_out.alpha = shape.get_opacity(gs.id);
435 out_position = gs.hP;
436
437 if (clip.constants.use_clipping) [[static_branch]] {
438 clip.set_clipping_distances(gs.wP,
439 clip_distances[0],
440 clip_distances[1],
441 clip_distances[2],
442 clip_distances[3],
443 clip_distances[4],
444 clip_distances[5]);
445 }
446}
447
449 [[resource_table]] const Resources &srt,
451 [[frag_coord]] const float4 frag_coord,
452 [[front_facing]] const bool in_frontfacing,
453 [[in]] const VertOut &v_in)
454{
455 /* Discard outline parts below a threshold. Otherwise, the gsplat outline shows billboards. */
456 float alpha = draw::gsplat::evaluate_gaussian(v_in.P, v_in.alpha);
457 if (alpha < 0.1f) {
459 }
460
461 if (pipe.selectable) [[static_branch]] {
462 if (srt.uniform_buf.backface_culling && !in_frontfacing) {
463 /* Return early since we are not using early depth testing. */
464 return;
465 }
466
467 /* This is optimized to NOP in the non select case. */
468 select.select_id_output(v_in.select_id, frag_coord);
469 }
470}
471
472} // namespace depth_only
473
474uint outline_colorid_get(ObjectInfos ob_infos, bool is_transform)
475{
476 eObjectInfoFlag ob_flag = ob_infos.flag;
477 bool is_active = flag_test(ob_flag, OBJECT_ACTIVE);
478
479 if (is_transform) {
480 return 0u; /* theme.colors.transform */
481 }
482 if (is_active) {
483 return 3u; /* theme.colors.active */
484 }
485 return 1u; /* theme.colors.object_select */
486}
487
489
490struct Resources {
492};
493struct VertOut {
494 [[flat]] uint ob_id;
495 [[flat]] float alpha;
497};
498struct FragOut {
499 [[frag_color(0)]] uint ob_id;
500};
501
503 [[resource_table]] const Resources &srt,
505 [[resource_table]] const draw::View &views,
506 [[resource_table]] const draw::Model &models,
507 [[resource_table]] const draw::Infos &infos,
508 [[resource_table, condition(!selectable)]] const draw::Resource &res_id,
510 condition(selectable)]] const draw::ResourceCustomID &custom_id,
511 [[vertex_id]] const int vert_id,
512 [[instance_index]] const int inst_index,
513 [[position]] float4 &out_position,
514 [[resource_table]] const Clipping &clip,
515 [[clip_distance, condition(use_clipping)]] float (&clip_distances)[6],
516 [[out]] VertOut &v_out)
517{
518 draw::ID id;
519 if (pipe.selectable) [[static_branch]] {
520 id = custom_id.get(inst_index);
521 }
522 else {
523 id = res_id.get(inst_index);
524 }
525 uint view_id = 0;
526 uint resource_id = id.resource_id<1>();
527
528 const ViewMatrices view = views.get(view_id);
529 const ObjectMatrices obj = models.get(resource_id);
530 const ObjectInfos ob_infos = infos.get(resource_id);
531 const draw::gsplat::SplatShape gs = shape.get_splat(uint(vert_id), obj, view);
532
533 if (gs.is_culled()) {
534 out_position = float4(NAN_FLT);
535 return;
536 }
537
538 /* Output splat billboard as position. */
539 out_position = gs.hP;
540
541 /* Small bias to always be on top of the geom. */
542 out_position.z -= 1e-3f;
543
544 /* ID 0 is nothing (background) */
545 v_out.ob_id = resource_id;
546
547 /* Should be 2 bits only [0..3]. */
548 uint outline_id = outline_colorid_get(ob_infos, srt.is_transform);
549
550 /* Combine for 16bit uint target. */
551 v_out.ob_id = outline_id_pack(outline_id, v_out.ob_id);
552
553 v_out.P = gs.shape_offset;
554 v_out.alpha = shape.get_opacity(gs.id);
555
556 if (clip.constants.use_clipping) [[static_branch]] {
557 clip.set_clipping_distances(gs.wP,
558 clip_distances[0],
559 clip_distances[1],
560 clip_distances[2],
561 clip_distances[3],
562 clip_distances[4],
563 clip_distances[5]);
564 }
565}
566
567[[fragment]] void frag([[in]] const VertOut &v_in, [[out]] FragOut &f_out)
568{
569 /* Discard outline parts below a threshold. Otherwise, the gsplat outline shows billboards. */
570 float alpha = draw::gsplat::evaluate_gaussian(v_in.P, v_in.alpha);
571 if (alpha < 0.1f) {
573 }
574
575 f_out.ob_id = v_in.ob_id;
576}
577
578} // namespace outline_prepass
579
580/* clang-format off */
581PipelineGraphic viewer_attribute_gsplat(viewer_attribute::vert, viewer_attribute::frag, ClippingConstant{.use_clipping = false}, PipelineResources{.selectable = false});
583
584PipelineGraphic edit_gsplat(edit_vert::vert, edit_vert::frag, ClippingConstant{.use_clipping = false}, PipelineResources{.selectable = false});
585PipelineGraphic edit_gsplat_clipped(edit_vert::vert, edit_vert::frag, ClippingConstant{.use_clipping = true}, PipelineResources{.selectable = false}); /* So anyway. */
586
587PipelineGraphic depth_gsplat(depth_only::vert, depth_only::frag, ClippingConstant{.use_clipping = false}, PipelineResources{.selectable = false});
588PipelineGraphic depth_gsplat_selectable(depth_only::vert, depth_only::frag, ClippingConstant{.use_clipping = false}, PipelineResources{.selectable = true});
589PipelineGraphic depth_gsplat_clipped(depth_only::vert, depth_only::frag, ClippingConstant{.use_clipping = true}, PipelineResources{.selectable = false});
590PipelineGraphic depth_gsplat_selectable_clipped(depth_only::vert, depth_only::frag, ClippingConstant{.use_clipping = true}, PipelineResources{.selectable = true});
591
592PipelineGraphic outline_prepass_gsplat(outline_prepass::vert, outline_prepass::frag, ClippingConstant{.use_clipping = false}, PipelineResources{.selectable = false});
596
597PipelineGraphic wireframe_gsplat(wireframe::vert, wireframe::frag, ClippingConstant{.use_clipping = false}, PipelineResources{.selectable = false});
598PipelineGraphic wireframe_gsplat_selectable(wireframe::vert, wireframe::frag, ClippingConstant{.use_clipping = false}, PipelineResources{.selectable = true});
599PipelineGraphic wireframe_gsplat_clipped(wireframe::vert, wireframe::frag, ClippingConstant{.use_clipping = true}, PipelineResources{.selectable = false});
600PipelineGraphic wireframe_gsplat_selectable_clipped(wireframe::vert, wireframe::frag, ClippingConstant{.use_clipping = true}, PipelineResources{.selectable = true});
601/* clang-format on */
602
603} // namespace overlay
#define NAN_FLT
btScalar max
#define OVERLAY_GLOBALS_SLOT
@ OBJECT_SELECTED
@ OBJECT_ACTIVE
@ OBJECT_FROM_SET
#define uniform(slot)
#define instance_index
#define point_size
#define position
#define front_facing
#define flat
#define frag_coord
#define smooth
#define push_constant
#define compilation_constant
#define resource_table
#define sampler(slot)
#define static_branch
#define fragment
#define vertex_id
#define clip_distance
#define condition(cond)
#define vertex
#define frag_color(slot)
#define point_coord
void gpu_discard_fragment()
#define abs
#define select(A, B, C)
#define sqrt
constexpr T clamp(T, U, U) RET
SamplerBase< float, 1 > samplerBuffer
float distance_squared(VecT a, VecT b)
bool flag_test(uint flag, uint val)
float evaluate_gaussian(float2 x_min_mu, float opacity)
float4 get_customdata_vec4(const int point_id, const samplerBuffer cd_buf)
void vert(const PipelineResources &pipe, const Resources &, const draw::gsplat::ShapeResource &shape, const draw::View &views, const draw::Model &models, const draw::Select &, const draw::Resource &res_id, const draw::ResourceCustomID &custom_id, const int vert_id, const int inst_index, float4 &out_position, const Clipping &clip, float(&clip_distances)[6], VertOut &v_out)
void frag(const PipelineResources &pipe, const Resources &srt, draw::Select &select, const float4 frag_coord, const bool in_frontfacing, const VertOut &v_in)
void frag(const float2 &in_pointcoord, const VertOut &v_in, FragOut &f_out)
void vert(const PipelineResources &pipe, const Resources &srt, const draw::gsplat::ShapeResource &shape, const draw::Resource &res_id, const draw::Model &models, const draw::View &views, const int vert_id, const int inst_index, float4 &out_position, float &out_pointsize, const Clipping &clip, float(&clip_distances)[6], VertOut &v_out)
void frag(const VertOut &v_in, FragOut &f_out)
void vert(const PipelineResources &pipe, const Resources &srt, const draw::gsplat::ShapeResource &shape, const draw::View &views, const draw::Model &models, const draw::Infos &infos, const draw::Resource &res_id, const draw::ResourceCustomID &custom_id, const int vert_id, const int inst_index, float4 &out_position, const Clipping &clip, float(&clip_distances)[6], VertOut &v_out)
void vert(const PipelineResources &pipe, const Resources &srt, const Clipping &clip, const draw::gsplat::ShapeResource &shape, const draw::Model &models, const draw::Infos &, const draw::View &views, const draw::Resource &res_id, const int vert_id, const int inst_index, float4 &out_position, float(&clip_distances)[6], VertOut &v_out)
void frag(const Resources &srt, const VertOut &v_in, FragOut &f_out)
void wire_color_get(float3 &rim_col, float3 &wire_col, const ObjectInfos &ob_infos, const Resources &srt)
void wire_object_color_get(float3 &rim_col, float3 &wire_col, const ObjectInfos &ob_infos, const Resources &srt)
void frag(const PipelineResources &pipe, const Resources &, draw::Select &select, const float2 &in_pointcoord, const float4 frag_coordinate, const VertOut &v_in, FragOut &f_out)
void vert(const PipelineResources &pipe, const Resources &srt, const draw::gsplat::ShapeResource &shape, const draw::Model &models, const draw::Infos &infos, const draw::View &views, const draw::Select &, const draw::Resource &res_id, const draw::ResourceCustomID &custom_id, const int vert_id, const int inst_index, float4 &out_position, float &out_pointsize, const Clipping &clip, float(&clip_distances)[6], VertOut &v_out)
PipelineGraphic edit_gsplat(edit_vert::vert, edit_vert::frag, ClippingConstant{.use_clipping=false}, PipelineResources{.selectable=false})
PipelineGraphic depth_gsplat(depth_only::vert, depth_only::frag, ClippingConstant{.use_clipping=false}, PipelineResources{.selectable=false})
PipelineGraphic wireframe_gsplat_selectable(wireframe::vert, wireframe::frag, ClippingConstant{.use_clipping=false}, PipelineResources{.selectable=true})
PipelineGraphic viewer_attribute_gsplat_clipped(viewer_attribute::vert, viewer_attribute::frag, ClippingConstant{.use_clipping=true}, PipelineResources{.selectable=false})
uint outline_colorid_get(ObjectInfos ob_infos, bool is_transform)
PipelineGraphic wireframe_gsplat(wireframe::vert, wireframe::frag, ClippingConstant{.use_clipping=false}, PipelineResources{.selectable=false})
PipelineGraphic edit_gsplat_clipped(edit_vert::vert, edit_vert::frag, ClippingConstant{.use_clipping=true}, PipelineResources{.selectable=false})
PipelineGraphic depth_gsplat_selectable(depth_only::vert, depth_only::frag, ClippingConstant{.use_clipping=false}, PipelineResources{.selectable=true})
PipelineGraphic viewer_attribute_gsplat(viewer_attribute::vert, viewer_attribute::frag, ClippingConstant{.use_clipping=false}, PipelineResources{.selectable=false})
PipelineGraphic depth_gsplat_clipped(depth_only::vert, depth_only::frag, ClippingConstant{.use_clipping=true}, PipelineResources{.selectable=false})
PipelineGraphic outline_prepass_gsplat_selectable(outline_prepass::vert, outline_prepass::frag, ClippingConstant{.use_clipping=false}, PipelineResources{.selectable=true})
PipelineGraphic wireframe_gsplat_selectable_clipped(wireframe::vert, wireframe::frag, ClippingConstant{.use_clipping=true}, PipelineResources{.selectable=true})
PipelineGraphic depth_gsplat_selectable_clipped(depth_only::vert, depth_only::frag, ClippingConstant{.use_clipping=true}, PipelineResources{.selectable=true})
PipelineGraphic outline_prepass_gsplat_clipped(outline_prepass::vert, outline_prepass::frag, ClippingConstant{.use_clipping=true}, PipelineResources{.selectable=false})
PipelineGraphic outline_prepass_gsplat_selectable_clipped(outline_prepass::vert, outline_prepass::frag, ClippingConstant{.use_clipping=true}, PipelineResources{.selectable=true})
PipelineGraphic wireframe_gsplat_clipped(wireframe::vert, wireframe::frag, ClippingConstant{.use_clipping=true}, PipelineResources{.selectable=false})
PipelineGraphic outline_prepass_gsplat(outline_prepass::vert, outline_prepass::frag, ClippingConstant{.use_clipping=false}, PipelineResources{.selectable=false})
@ V3D_SHADING_OBJECT_COLOR
@ V3D_SHADING_RANDOM_COLOR
#define mix
#define saturate(a)
Definition smaa.cc:319
enum eObjectInfoFlag flag
float4 point_world_to_homogenous(float3 P) const
float3 world_incident_vector(float3 P) const
float x
float y
float z
Definition sky_math.h:136
float y
Definition sky_math.h:136
float x
Definition sky_math.h:136
float z
Definition sky_math.h:225