37 float sine = 1.0f - ax * ax - az * az;
38 float q3 =
sqrt(
max(0.0f, sine));
40 return float3(-az * q3, 0.5f - sine, ax * q3) * 2.0f;
55 float4x4 inst_obmat = srt.data_buf[inst_index].object_to_world;
57 model_mat[0][3] = model_mat[1][3] = model_mat[2][3] = 0.0f;
58 model_mat[3][3] = 1.0f;
60 float2 amin =
float2(inst_obmat[0][3], inst_obmat[1][3]);
61 float2 amax =
float2(inst_obmat[2][3], inst_obmat[3][3]);
64 v_in.pos.y *
abs((v_in.pos.y > 0.0f) ? amax.
y : amin.
y));
66 float3 world_pos = (model_mat *
float4(final_pos, 1.0f)).xyz;
70 v_out.final_color = srt.data_buf[inst_index].color_;
71 v_out.final_color.a *=
armature.alpha;
73 v_out.edge_start = v_out.edge_pos = ((out_pos.xy / out_pos.w) * 0.5f + 0.5f) *
74 uni.uniform_buf.size_viewport;
77 clip.set_clipping_distances(world_pos,
91 frag_out.color = v_out.final_color;
92 frag_out.line_output =
float4(0.0f);
113 bool is_persp = (view.
winmat[3][3] == 0.0f);
117 float cam_dist =
length(cam_ray);
120 float3 z_axis = cam_ray / cam_dist;
130 constexpr float half_pi = 3.1415926f * 0.5f;
137 float a = half_pi -
asin(rad / cam_dist);
138 float cos_b =
cos(a);
139 float sin_b =
sqrt(
clamp(1.0f - cos_b * cos_b, 0.0f, 1.0f));
143 z_ofs = -rad * cos_b;
146 return float3x3(x_axis, y_axis, z_axis);
169 return dot(p,
b.vec) > -
b.sinb;
184 float3 wpos = mat_near *
float3(pos * sph_near.
w, z_ofs_near);
186 wpos = sph_far.xyz + mat_far *
float3(pos * sph_far.
w, z_ofs_far);
189 wpos += sph_near.xyz;
209 sel_out.select_id = sel.in_select_buf[inst_index];
214 float dst_head =
distance(srt.data_buf[inst_index].head_sphere.xyz, view.
viewinv[3].xyz);
215 float dst_tail =
distance(srt.data_buf[inst_index].tail_sphere.xyz, view.
viewinv[3].xyz);
220 if ((dst_head > dst_tail) && (view.
winmat[3][3] == 0.0f)) {
221 sph_near = srt.data_buf[inst_index].tail_sphere;
222 sph_far = srt.data_buf[inst_index].head_sphere;
225 sph_near = srt.data_buf[inst_index].head_sphere;
226 sph_far = srt.data_buf[inst_index].tail_sphere;
229 float3 bone_vec = (sph_far.xyz - sph_near.xyz) + 1e-8f;
232 float bone_lenrcp = 1.0f /
max(1e-8f,
sqrt(
dot(bone_vec, bone_vec)));
233 b.sinb = (sph_far.
w - sph_near.
w) * bone_lenrcp * sph_near.
w;
234 b.vec = bone_vec * bone_lenrcp;
236 float z_ofs_near, z_ofs_far;
241 v_in.pos0, sph_near, sph_far, mat_near, mat_far, z_ofs_near, z_ofs_far,
b);
243 v_in.pos1, sph_near, sph_far, mat_near, mat_far, z_ofs_near, z_ofs_far,
b);
245 v_in.pos2, sph_near, sph_far, mat_near, mat_far, z_ofs_near, z_ofs_far,
b);
248 clip.set_clipping_distances(wpos1,
265 float2 ss0 = uni.proj(p0);
266 float2 ss1 = uni.proj(p1);
267 float2 ss2 = uni.proj(p2);
271 out_pos.xy += ofs_dir * uni.uniform_buf.size_viewport_inv * out_pos.w;
273 v_out.edge_start = v_out.edge_pos = uni.proj(out_pos);
275 v_out.final_color =
float4(srt.data_buf[inst_index].bone_color_and_wire_width.rgb,
311 sel_out.select_id = sel.in_select_buf[inst_index];
316 float3 bone_vec = srt.data_buf[inst_index].tail_sphere.xyz -
317 srt.data_buf[inst_index].head_sphere.xyz;
318 float bone_len =
max(1e-8f,
sqrt(
dot(bone_vec, bone_vec)));
319 float bone_lenrcp = 1.0f / bone_len;
321 float sinb = (srt.data_buf[inst_index].tail_sphere.w - srt.data_buf[inst_index].head_sphere.w) *
324 constexpr float sinb = 0.0f;
327 float3 y_axis = bone_vec * bone_lenrcp;
333 nor = sp = v_in.pos.xyz;
336 bool is_head = (v_in.pos.z < -sinb);
337 sp *= (is_head) ? srt.data_buf[inst_index].head_sphere.w :
338 srt.data_buf[inst_index].tail_sphere.w;
339 sp.
z += (is_head) ? 0.0f : bone_len;
343 sp = bone_mat * sp.xzy + srt.data_buf[inst_index].head_sphere.xyz;
344 nor = bone_mat * nor.xzy;
346 v_out.view_normal = to_float3x3(view.
viewmat) * nor;
348 v_out.final_state_color = srt.data_buf[inst_index].state_color.xyz;
349 v_out.final_bone_color = srt.data_buf[inst_index].bone_color_and_wire_width.xyz;
352 clip.set_clipping_distances(sp,
374 float n =
normalize(v_out.view_normal).z;
375 if (srt.is_distance) {
376 n = 1.0f -
clamp(-n, 0.0f, 1.0f);
377 frag_out.color =
float4(1.0f, 1.0f, 1.0f, 0.33f *
armature.alpha) * n;
381 constexpr float s = 0.2f;
382 float fac =
clamp((n * (1.0f - s)) + s, 0.0f, 1.0f);
383 frag_out.color.rgb =
mix(v_out.final_state_color, v_out.final_bone_color, fac * fac);
386 frag_out.line_output =
float4(0.0f);
389 sel.select_id_output(sel_out.select_id, frag_co);
469 return {.ls_P = ls_P, .inst_matrix = inst_matrix};
474 float4 bone_color, state_color;
482 v_out.
inverted = int(
dot(
cross(model_mat[0].xyz, model_mat[1].xyz), model_mat[2].xyz) < 0.0f);
490 uint out_primitive_id,
500 bool is_odd_primitive = (out_primitive_id & 1u) != 0u;
502 uint out_strip_index = (is_odd_primitive ? (2u - out_vertex_id) : out_vertex_id) +
505 if (out_strip_index != strip_index) {
515 out_pos.
z -= (is_persp) ? 1e-4f : 1e-6f;
526 uint out_primitive_id,
532 bool is_persp = (view.
winmat[3][3] == 0.0f);
546 float fac0 =
dot(view_vec, n0);
547 float fac3 =
dot(view_vec, n3);
551 if (
abs(fac0) > 1e-5f &&
abs(fac3) > 1e-5f) {
559 n0 = (geom_in[0].
inverted == 1) ? -n0 : n0;
561 if (
dot(n0, v13) > 0.0001f) {
574 if (geom_in[0].vs_P.z < geom_in[3].
vs_P.
z) {
575 hidden_point = (
abs(fac0) > 1e-5f) ? geom_in[0].ss_P : geom_in[3].
ss_P;
578 hidden_point = (
abs(fac3) > 1e-5f) ? geom_in[3].ss_P : geom_in[0].
ss_P;
582 float fac =
dot(-hidden_dir, edge_dir);
583 edge_dir *= (fac < 0.0f) ? -1.0f : 1.0f;
588 float4(geom_in[0].color_size.rgb, 1.0f),
600 float4(geom_in[0].color_size.rgb, 1.0f),
625 sel_out.select_id = sel.in_select_buf[inst_index];
629 constexpr uint input_primitive_vertex_count = 4u;
631 constexpr uint output_primitive_vertex_count = 2u;
632 constexpr uint output_primitive_count = 1u;
633 constexpr uint output_invocation_count = 1u;
634 constexpr uint output_vertex_count_per_invocation = output_primitive_count *
635 output_primitive_vertex_count;
636 constexpr uint output_vertex_count_per_input_primitive = output_vertex_count_per_invocation *
637 output_invocation_count;
639 uint in_primitive_id = uint(vert_id) / output_vertex_count_per_input_primitive;
640 uint in_primitive_first_vertex = in_primitive_id * input_primitive_vertex_count;
642 uint out_vertex_id = uint(vert_id) % output_primitive_vertex_count;
643 uint out_primitive_id = (uint(vert_id) / output_primitive_vertex_count) % output_primitive_count;
644 uint out_invocation_id = (uint(vert_id) / output_vertex_count_per_invocation) %
645 output_invocation_count;
647 float4x4 inst_matrix = srt.data_buf[inst_index];
649 VertIn vert_in[input_primitive_vertex_count];
650 vert_in[0] = srt.input_assembly(in_primitive_first_vertex + 0u, inst_matrix);
651 vert_in[1] = srt.input_assembly(in_primitive_first_vertex + 1u, inst_matrix);
652 vert_in[2] = srt.input_assembly(in_primitive_first_vertex + 2u, inst_matrix);
653 vert_in[3] = srt.input_assembly(in_primitive_first_vertex + 3u, inst_matrix);
657 VertOut vert_out[input_primitive_vertex_count];
658 vert_out[0] = srt.vertex_main(view, vert_in[0]);
659 vert_out[1] = srt.vertex_main(view, vert_in[1]);
660 vert_out[2] = srt.vertex_main(view, vert_in[2]);
661 vert_out[3] = srt.vertex_main(view, vert_in[3]);
667 view, vert_out, out_vertex_id, out_primitive_id, out_invocation_id, v_out, out_pos, ws_P);
670 clip.set_clipping_distances(ws_P,
679 v_out.final_color.a =
armature.alpha;
714 sel_out.select_id = sel.in_select_buf[inst_index];
719 float4 bone_color, state_color;
720 float4x4 inst_obmat = srt.data_buf[inst_index];
726 float3 normal =
normalize(view.normal_world_to_view(normal_mat * v_in.nor));
728 v_out.inverted = int(
dot(
cross(model_mat[0].xyz, model_mat[1].xyz), model_mat[2].xyz) < 0.0f);
732 float n =
dot(normal, light);
735 constexpr float s = 0.2f;
736 float fac =
clamp((n * (1.0f - s)) + s, 0.0f, 1.0f);
737 v_out.final_color.rgb =
mix(state_color.rgb, bone_color.rgb, fac * fac);
738 v_out.final_color.a =
armature.alpha;
744 clip.set_clipping_distances(ws_P,
765 if ((v_out.inverted == 1) == facing) {
769 frag_out.color = v_out.final_color;
770 frag_out.line_output =
float4(0.0f);
773 sel.select_id_output(sel_out.select_id, frag_co);
818 return {.lP = ls_P, .inst_matrix = inst_matrix};
823 float4 bone_color, state_color;
837 uint axis = uint(vpos.
z);
840 vofs[axis] = (1.0f +
fract(vpos.
z));
843 vpos *=
length(model_mat[axis].xyz);
853 v_out.
final_color.rgb =
mix(state_color.rgb, bone_color.rgb, 0.5f);
863 uint out_primitive_id,
873 bool is_odd_primitive = (out_primitive_id & 1u) != 0u;
875 uint out_strip_index = (is_odd_primitive ? (2u - out_vertex_id) : out_vertex_id) +
878 if (out_strip_index != strip_index) {
886 out_pos.xy += offset * 2.0f * hs_P.
w;
892 uint out_primitive_id,
908 float4 pos01 = pos0 - pos1;
909 float ofs =
abs((pz_ndc.
y + 1.0f) / (pz_ndc.
x - pz_ndc.
y));
913 else if (clipped.x) {
914 pos0 -= pos01 * (1.0f - ofs);
917 float2 screen_space_pos[2];
918 screen_space_pos[0] = pos0.xy / pos0.
w;
919 screen_space_pos[1] = pos1.xy / pos1.
w;
941 geom_in[0].world_pos,
952 geom_in[0].world_pos,
964 geom_in[1].world_pos,
975 geom_in[1].world_pos,
999 sel_out.select_id = sel.in_select_buf[inst_index];
1005 uint input_primitive_vertex_count = 2u;
1008 input_primitive_vertex_count = 1u;
1011 constexpr uint output_primitive_vertex_count = 3u;
1012 constexpr uint output_primitive_count = 2u;
1013 constexpr uint output_invocation_count = 1u;
1014 constexpr uint output_vertex_count_per_invocation = output_primitive_count *
1015 output_primitive_vertex_count;
1016 constexpr uint output_vertex_count_per_input_primitive = output_vertex_count_per_invocation *
1017 output_invocation_count;
1019 uint in_primitive_id = uint(vert_id) / output_vertex_count_per_input_primitive;
1020 uint in_primitive_first_vertex = in_primitive_id * input_primitive_vertex_count;
1022 uint out_vertex_id = uint(vert_id) % output_primitive_vertex_count;
1023 uint out_primitive_id = (uint(vert_id) / output_primitive_vertex_count) % output_primitive_count;
1024 uint out_invocation_id = (uint(vert_id) / output_vertex_count_per_invocation) %
1025 output_invocation_count;
1027 float4x4 inst_obmat = srt.data_buf[inst_index];
1031 uint32_t RESTART_INDEX = srt.indices.gpu_index_16bit ? 0xFFFF : 0xFFFFFFFF;
1032 if (srt.indices.load(in_primitive_first_vertex + 0u) == RESTART_INDEX ||
1033 srt.indices.load(in_primitive_first_vertex + 1u) == RESTART_INDEX)
1042 vert_in[0] = srt.input_assembly(in_primitive_first_vertex + 0u, inst_matrix);
1043 vert_in[1] = srt.input_assembly(in_primitive_first_vertex + 1u, inst_matrix);
1046 vert_out[0] = srt.vertex_main(view, vert_in[0]);
1047 vert_out[1] = srt.vertex_main(view, vert_in[1]);
1053 vert_out, out_vertex_id, out_primitive_id, out_invocation_id, v_out, out_pos, ws_P);
1055 v_out.final_color.a =
armature.alpha;
1058 clip.set_clipping_distances(ws_P,
1070 if (do_smooth_wire) {
1073 return step(0.5f, dist);
1084 float half_size = (srt.do_smooth_wire ? v_out.wire_width - 0.5f : v_out.wire_width) / 2.0f;
1086 float dist =
abs(v_out.edge_coord) - half_size;
1089 frag_out.color =
mix(v_out.final_color,
float4(0), mix_w);
1090 frag_out.color.a *= 1.0f - mix_w;
1091 frag_out.line_output =
float4(0.0f);
1094 sel.select_id_output(sel_out.select_id, frag_co);
1174 .from_line_strip =
true},
1211 sel_out.select_id = sel.in_select_buf[inst_index];
1216 float4 bone_color, state_color;
1217 float4x4 inst_obmat = srt.data_buf[inst_index];
1223 bool is_persp = (view.
winmat[3][3] == 0.0f);
1228 float3 cam_ray = (is_persp) ? model_view_matrix[3].xyz :
float3(0.0f, 0.0f, -1.0f);
1229 cam_ray = to_float3x3(sphere_matrix) * cam_ray;
1232 float cam_dist =
length(cam_ray);
1235 float3 z_axis = cam_ray / cam_dist;
1245 constexpr float half_pi = 3.1415926f * 0.5f;
1246 constexpr float rad = 0.05f;
1252 float a = half_pi -
asin(rad / cam_dist);
1253 float cos_b =
cos(a);
1254 float sin_b =
sqrt(
clamp(1.0f - cos_b * cos_b, 0.0f, 1.0f));
1258 z_ofs = -rad * cos_b;
1262 float3 cam_pos0 = x_axis * v_in.pos.
x + y_axis * v_in.pos.
y + z_axis * z_ofs;
1270 out_pos.xy += ofs_dir * uni.uniform_buf.size_viewport_inv * out_pos.w;
1272 v_out.edge_start = v_out.edge_pos = uni.proj(out_pos);
1279 clip.set_clipping_distances(world_pos,
1327 sel_out.select_id = sel.in_select_buf[inst_index];
1332 float4 bone_color, state_color;
1333 float4x4 inst_obmat = srt.data_buf[inst_index];
1338 v_out.sphere_matrix0 = sphere_matrix[0];
1339 v_out.sphere_matrix1 = sphere_matrix[1];
1340 v_out.sphere_matrix2 = sphere_matrix[2];
1341 v_out.sphere_matrix3 = sphere_matrix[3];
1343 bool is_persp = (view.
winmat[3][3] == 0.0f);
1348 float3 cam_ray = (is_persp) ? model_view_matrix[3].xyz :
float3(0.0f, 0.0f, -1.0f);
1349 cam_ray = to_float3x3(sphere_matrix) * cam_ray;
1352 float cam_dist =
length(cam_ray);
1355 float3 z_axis = cam_ray / cam_dist;
1360 constexpr float rad = 0.05f;
1362 float z_ofs = -rad - 1e-8f;
1368 constexpr float half_pi = 3.1415926f * 0.5f;
1374 float a = half_pi -
asin(rad / cam_dist);
1375 float cos_b =
cos(a);
1376 float sin_b =
sqrt(
clamp(1.0f - cos_b * cos_b, 0.0f, 1.0f));
1382 float minor = cam_dist - rad;
1383 float major = cam_dist - cos_b * rad;
1384 float fac = minor / major;
1387 z_ofs = -rad * cos_b;
1394 float3 cam_pos = x_axis * v_in.pos.
x + y_axis * v_in.pos.
y + z_axis * z_ofs;
1397 float4 V = model_view_matrix * pos_4d;
1399 v_out.view_position =
V.xyz;
1401 v_out.final_state_color = state_color.xyz;
1402 v_out.final_bone_color = bone_color.xyz;
1407 clip.set_clipping_distances(world_pos,
1429 constexpr float sphere_radius = 0.05f;
1431 sphere_matrix[0] = v_out.sphere_matrix0;
1432 sphere_matrix[1] = v_out.sphere_matrix1;
1433 sphere_matrix[2] = v_out.sphere_matrix2;
1434 sphere_matrix[3] = v_out.sphere_matrix3;
1436 bool is_perp = (view.
winmat[3][3] == 0.0f);
1437 float3 ray_ori_view = (is_perp) ?
float3(0.0f) : v_out.view_position.xyz;
1438 float3 ray_dir_view = (is_perp) ? v_out.view_position :
float3(0.0f, 0.0f, -1.0f);
1441 float4 mul_vec = (is_perp) ?
float4(ray_dir_view, 0.0f) :
float4(ray_ori_view, 1.0f);
1442 float3 mul_res = (sphere_matrix * mul_vec).xyz;
1449 float3 ray_ori = (is_perp) ? sphere_matrix[3].xyz : mul_res;
1450 float3 ray_dir = (is_perp) ? mul_res : -sphere_matrix[2].xyz;
1451 float ray_len =
length(ray_dir);
1455 constexpr float sphere_radius_sqr = sphere_radius * sphere_radius;
1456 float b =
dot(ray_ori, ray_dir);
1457 float c =
dot(ray_ori, ray_ori) - sphere_radius_sqr;
1458 float h =
b *
b - c;
1462 float3 p = ray_dir * t + ray_ori;
1467 constexpr float s = 0.2f;
1468 float fac =
clamp((
dot(n, l) * (1.0f - s)) + s, 0.0f, 1.0f);
1469 frag_out.color.rgb =
mix(v_out.final_state_color, v_out.final_bone_color, fac * fac);
1473 dither *= (1.0f / 255.0f);
1475 frag_out.color =
float4(frag_out.color.rgb + dither,
armature.alpha);
1476 frag_out.line_output =
float4(0.0f);
1481 sel.select_id_output(sel_out.select_id, frag_co);
1563 sel_out.select_id = sel.in_select_buf[inst_index];
1569 v_out.final_inner_color =
flag_test(bone_flag,
COL_HEAD) ? srt.data_buf[inst_index].head_color :
1570 srt.data_buf[inst_index].tail_color;
1571 v_out.final_inner_color =
flag_test(bone_flag,
COL_BONE) ? srt.data_buf[inst_index].bone_color :
1572 v_out.final_inner_color;
1573 v_out.final_wire_color = (srt.data_buf[inst_index].wire_color.a > 0.0f) ?
1574 srt.data_buf[inst_index].wire_color :
1575 v_out.final_inner_color;
1580 float4 boneStart_4d =
float4(srt.data_buf[inst_index].bone_start.xyz, 1.0f);
1581 float4 boneEnd_4d =
float4(srt.data_buf[inst_index].bone_end.xyz, 1.0f);
1587 float clip_dist = (view.
winmat[3][3] == 0.0f) ?
1590 float3 bvec = v1.xyz - v0.xyz;
1591 float3 clip_pt = v0.xyz + bvec * ((v0.
z - clip_dist) / -bvec.
z);
1592 if (v0.
z > clip_dist) {
1595 else if (v1.
z > clip_dist) {
1605 float h = (is_head) ? p0.
w : p1.
w;
1611 float2 vpos = v_in.pos.
x * x_screen_vec + v_in.pos.
y * y_screen_vec;
1612 vpos *= (view.
winmat[3][3] == 0.0f) ? h : 1.0f;
1613 vpos *= (srt.data_buf[inst_index].wire_color.a > 0.0f) ? 1.0f : 0.5f;
1615 if (v_out.final_inner_color.a > 0.0f) {
1616 float stick_size = uni.uniform_buf.sizes.pixel * 5.0f;
1617 out_pos = (is_head) ? p0 : p1;
1618 out_pos.xy += stick_size * (vpos * uni.uniform_buf.size_viewport_inv);
1619 out_pos.
z += (is_bone) ? 0.0f : 1e-6f;
1622 clip.set_clipping_distances((is_head ? boneStart_4d : boneEnd_4d).xyz,
1644 float fac =
smoothstep(1.0f, 0.2f, v_out.color_fac);
1645 frag_out.color.rgb =
mix(v_out.final_inner_color.rgb, v_out.final_wire_color.rgb, fac);
1647 frag_out.line_output =
float4(0.0f);
1650 sel.select_id_output(sel_out.select_id, frag_co);
1699 sel_out.select_id = sel.in_select_buf[vert_id / 2];
1704 v_out.final_color.rgb = srt.data_buf[vert_id].color_.rgb;
1705 v_out.final_color.a =
armature.alpha;
1707 float3 world_pos = srt.data_buf[vert_id].pos_.xyz;
1710 v_out.edge_start = v_out.edge_pos = ((out_pos.xy / out_pos.w) * 0.5f + 0.5f) *
1711 uni.uniform_buf.size_viewport;
1714 clip.set_clipping_distances(world_pos,
float3 gpu_attr_load_float3(const float(&data_buf)[], int2 stride_and_offset, uint i)
#define storage(slot, qualifiers)
#define compilation_constant
T smoothstep(T, T, T) RET
void gpu_discard_fragment()
MatBase< C, R > inverse(MatBase< C, R >) RET
VecBase< float, D > normalize(VecOp< float, D >) RET
float dot(VecOp< float, D >, VecOp< float, D >) RET
float distance(float, float) RET
bool all(VecOp< bool, D >) RET
VecBase< float, D > step(VecOp< float, D >, VecOp< float, D >) RET
MatBase< R, C > transpose(MatBase< C, R >) RET
VecBase< float, 3 > cross(VecOp< float, 3 >, VecOp< float, 3 >) RET
VecBase< bool, D > lessThan(VecOp< T, D >, VecOp< T, D >) RET
constexpr T clamp(T, U, U) RET
float length(VecOp< float, D >) RET
bool flag_test(uint flag, uint val)
MatBase< float, 4, 4 > float4x4
float3 sphere_project(float ax, float az)
void vert(const Resources &srt, const Armature &armature, const Uniform &uni, const Clipping &clip, const draw::View &views, const int inst_index, float(&clip_distances)[6], const VertIn &v_in, VertOut &v_out, float4 &out_pos)
void frag(const VertOut &v_out, FragOut &frag_out)
float3 get_outline_point(float2 pos, float4 sph_near, float4 sph_far, float3x3 mat_near, float3x3 mat_far, float z_ofs_near, float z_ofs_far, Bone b)
void vert(const Resources &srt, const Armature &armature, const Uniform &uni, const Clipping &clip, const draw::View &views, const draw::Select &sel, draw::SelectOut &sel_out, const int inst_index, float(&clip_distances)[6], const VertIn &v_in, VertOut &v_out, float4 &out_pos)
bool bone_blend_starts(float3 p, Bone b)
void vert(const Resources &srt, const Clipping &clip, const draw::View &views, const draw::Select &sel, draw::SelectOut &sel_out, const int inst_index, float(&clip_distances)[6], const VertIn &v_in, VertOut &v_out, float4 &out_pos)
void frag(const Resources &srt, const Armature &armature, draw::Select &sel, const float4 frag_co, const VertOut &v_out, const draw::SelectOut &sel_out, FragOut &frag_out)
float3x3 compute_mat(ViewMatrices view, float4 sphere, float3 bone_vec, float &z_ofs)
void vert(const Resources &srt, const Armature &armature, const Clipping &clip, const draw::View &views, const draw::Select &sel, draw::SelectOut &sel_out, const int vert_id, const int inst_index, float(&clip_distances)[6], overlay::VertOut &v_out, float4 &out_pos)
void vert(const Resources &srt, const Armature &armature, const Clipping &clip, const draw::View &views, const draw::Select &sel, draw::SelectOut &sel_out, const int inst_index, float(&clip_distances)[6], const VertIn &v_in, VertOut &v_out, float4 &out_pos)
void frag(draw::Select &sel, const float4 frag_co, const bool facing, const VertOut &v_out, const draw::SelectOut &sel_out, FragOut &frag_out)
float edge_step(bool do_smooth_wire, float dist)
void frag(const Resources &srt, draw::Select &sel, const float4 frag_co, const GeomOut &v_out, const draw::SelectOut &sel_out, FragOut &frag_out)
void vert(const Resources &srt, const Constants &consts, const Armature &armature, const Clipping &clip, const draw::View &views, const draw::Select &sel, draw::SelectOut &sel_out, const int vert_id, const int inst_index, float(&clip_distances)[6], GeomOut &v_out, float4 &out_pos)
void vert(const Resources &srt, const Armature &armature, const Uniform &uni, const Clipping &clip, const draw::View &views, const draw::Select &sel, draw::SelectOut &sel_out, const int inst_index, float(&clip_distances)[6], const VertIn &v_in, VertOut &v_out, float4 &out_pos)
void frag(const Armature &armature, const draw::View &views, draw::Select &sel, const float4 frag_co, const VertOut &v_out, const draw::SelectOut &sel_out, float &depth_out, FragOut &frag_out)
void vert(const Resources &srt, const Clipping &clip, const draw::View &views, const draw::Select &sel, draw::SelectOut &sel_out, const int inst_index, float(&clip_distances)[6], const VertIn &v_in, VertOut &v_out, float4 &out_pos)
void vert(const Resources &srt, const Uniform &uni, const Clipping &clip, const draw::View &views, const draw::Select &sel, draw::SelectOut &sel_out, const int inst_index, float(&clip_distances)[6], const VertIn &v_in, VertOut &v_out, float4 &out_pos)
void frag(const Armature &armature, draw::Select &sel, const float4 frag_co, const VertOut &v_out, const draw::SelectOut &sel_out, FragOut &frag_out)
void vert(const Resources &srt, const Armature &armature, const Uniform &uni, const Clipping &clip, const draw::View &views, const draw::Select &sel, draw::SelectOut &sel_out, const int vert_id, float(&clip_distances)[6], VertOut &v_out, float4 &out_pos)
PipelineGraphic envelope_solid(envelope::solid::vert, envelope::solid::frag, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=false})
PipelineGraphic sphere_outline_clipped(sphere::outline::vert, wire_frag, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=false})
PipelineGraphic wire_selectable_clipped(wire_bone::vert, wire_frag, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=true})
PipelineGraphic shape_solid_selectable_clipped(shape::solid::vert, shape::solid::frag, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=true})
PipelineGraphic stick(stick_bone::vert, stick_bone::frag, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=false})
PipelineGraphic envelope_outline_selectable(envelope::outline::vert, wire_frag, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=true})
PipelineGraphic sphere_solid_clipped(sphere::solid::vert, sphere::solid::frag, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=false})
PipelineGraphic shape_wire_clipped(shape::wire::vert, shape::wire::frag, shape::wire::Constants{.from_line_strip=false}, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=false})
PipelineGraphic shape_outline_selectable_clipped(shape::outline::vert, wire_frag, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=true})
PipelineGraphic shape_wire_selectable(shape::wire::vert, shape::wire::frag, shape::wire::Constants{.from_line_strip=false}, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=true})
PipelineGraphic sphere_solid_selectable_clipped(sphere::solid::vert, sphere::solid::frag, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=true})
PipelineGraphic envelope_outline(envelope::outline::vert, wire_frag, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=false})
PipelineGraphic shape_solid(shape::solid::vert, shape::solid::frag, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=false})
PipelineGraphic shape_solid_selectable(shape::solid::vert, shape::solid::frag, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=true})
PipelineGraphic stick_clipped(stick_bone::vert, stick_bone::frag, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=false})
PipelineGraphic wire(wire_bone::vert, wire_frag, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=false})
PipelineGraphic dof_clipped(degrees_of_freedom::vert, degrees_of_freedom::frag, ClippingConstant{.use_clipping=true})
PipelineGraphic sphere_outline(sphere::outline::vert, wire_frag, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=false})
PipelineGraphic shape_solid_clipped(shape::solid::vert, shape::solid::frag, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=false})
PipelineGraphic envelope_solid_clipped(envelope::solid::vert, envelope::solid::frag, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=false})
PipelineGraphic wire_clipped(wire_bone::vert, wire_frag, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=false})
PipelineGraphic sphere_solid(sphere::solid::vert, sphere::solid::frag, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=false})
PipelineGraphic shape_wire_strip_clipped(shape::wire::vert, shape::wire::frag, shape::wire::Constants{.from_line_strip=true}, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=false})
PipelineGraphic stick_selectable(stick_bone::vert, stick_bone::frag, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=true})
PipelineGraphic shape_wire_selectable_clipped(shape::wire::vert, shape::wire::frag, shape::wire::Constants{.from_line_strip=false}, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=true})
PipelineGraphic stick_selectable_clipped(stick_bone::vert, stick_bone::frag, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=true})
PipelineGraphic shape_outline(shape::outline::vert, wire_frag, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=false})
PipelineGraphic sphere_outline_selectable(sphere::outline::vert, wire_frag, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=true})
PipelineGraphic envelope_outline_clipped(envelope::outline::vert, wire_frag, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=false})
PipelineGraphic shape_outline_selectable(shape::outline::vert, wire_frag, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=true})
PipelineGraphic envelope_solid_selectable_clipped(envelope::solid::vert, envelope::solid::frag, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=true})
PipelineGraphic sphere_outline_selectable_clipped(sphere::outline::vert, wire_frag, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=true})
PipelineGraphic shape_wire_strip(shape::wire::vert, shape::wire::frag, shape::wire::Constants{.from_line_strip=true}, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=false})
PipelineGraphic shape_wire_strip_selectable(shape::wire::vert, shape::wire::frag, shape::wire::Constants{.from_line_strip=true}, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=true})
PipelineGraphic envelope_solid_selectable(envelope::solid::vert, envelope::solid::frag, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=true})
PipelineGraphic shape_wire_strip_selectable_clipped(shape::wire::vert, shape::wire::frag, shape::wire::Constants{ .from_line_strip=true}, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=true})
PipelineGraphic envelope_outline_selectable_clipped(envelope::outline::vert, wire_frag, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=true})
PipelineGraphic wire_selectable(wire_bone::vert, wire_frag, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=true})
PipelineGraphic shape_outline_clipped(shape::outline::vert, wire_frag, ClippingConstant{.use_clipping=true}, draw::SelectConstant{.selectable=false})
PipelineGraphic shape_wire(shape::wire::vert, shape::wire::frag, shape::wire::Constants{.from_line_strip=false}, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=false})
PipelineGraphic sphere_solid_selectable(sphere::solid::vert, sphere::solid::frag, ClippingConstant{.use_clipping=false}, draw::SelectConstant{.selectable=true})
PipelineGraphic dof(degrees_of_freedom::vert, degrees_of_freedom::frag, ClippingConstant{.use_clipping=false})
void wire_frag(draw::Select &sel, const float4 frag_co, const VertOut &v_out, const draw::SelectOut &sel_out, FragOut &frag_out)
float2 compute_dir(float2 v0, float2, float2 v2)
float4x4 extract_matrix_packed_data(float4x4 mat, float4 &dataA, float4 &dataB)
#define LINE_SMOOTH_START
#define WIRE_WIDTH_COMPRESSION
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
BoneEnvelopeData()=default
uint load(uint element_index) const
float3 point_world_to_view(float3 P) const
float3 perspective_divide(float4 hs_P) const
float4 point_view_to_homogenous(float3 vP) const
float4 point_world_to_homogenous(float3 P) const
float depth_view_to_screen(float v_depth) const
const ExtraInstanceData(& data_buf)[]
const BoneEnvelopeData(& data_buf)[]
const BoneEnvelopeData(& data_buf)[]
VertOut vertex_main(const ViewMatrices view, VertIn v_in) const
void geometry_main(const ViewMatrices view, const VertOut geom_in[4], uint out_vertex_id, uint out_primitive_id, uint, overlay::VertOut &v_out, float4 &out_pos, float3 &out_wP) const
void emit_vertex(const uint strip_index, uint out_vertex_id, uint out_primitive_id, float4 color, float4 hs_P, float3 ws_P, float2 offset, bool is_persp, overlay::VertOut &v_out, float4 &out_pos, float3 &out_wP) const
VertIn input_assembly(uint in_vertex_id, float4x4 inst_matrix) const
const float4x4(& data_buf)[]
void geometry_main(VertOut geom_in[2], uint out_vertex_id, uint out_primitive_id, uint, GeomOut &v_out, float4 &out_pos, float3 &out_wP) const
VertOut vertex_main(const ViewMatrices view, VertIn v_in) const
VertIn input_assembly(uint in_vertex_id, float4x4 inst_matrix) const
void do_vertex(const uint strip_index, uint out_vertex_id, uint out_primitive_id, float4 color, float4 hs_P, float3 ws_P, float coord, float2 offset, GeomOut &v_out, float4 &out_pos, float3 &out_wP) const
const float4x4(& data_buf)[]
const float4x4(& data_buf)[]
const BoneStickData(& data_buf)[]
const VertexData(& data_buf)[]
CCL_NAMESPACE_BEGIN struct Window V