1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
|
/* To be compiled with common_subdiv_lib.glsl */
layout(std430, binding = 0) readonly buffer inputVertexData
{
PosNorLoop pos_nor[];
};
layout(std430, binding = 1) readonly buffer inputEdgeIndex
{
uint input_edge_index[];
};
layout(std430, binding = 2) writeonly buffer outputEdgeFactors
{
#ifdef GPU_AMD_DRIVER_BYTE_BUG
float output_edge_fac[];
#else
uint output_edge_fac[];
#endif
};
void write_vec4(uint index, vec4 edge_facs)
{
#ifdef GPU_AMD_DRIVER_BYTE_BUG
for (uint i = 0; i < 4; i++) {
output_edge_fac[index + i] = edge_facs[i];
}
#else
/* Use same scaling as in extract_edge_fac_iter_poly_mesh. */
uint a = uint(clamp(edge_facs.x * 253.0 + 1.0, 0.0, 255.0));
uint b = uint(clamp(edge_facs.y * 253.0 + 1.0, 0.0, 255.0));
uint c = uint(clamp(edge_facs.z * 253.0 + 1.0, 0.0, 255.0));
uint d = uint(clamp(edge_facs.w * 253.0 + 1.0, 0.0, 255.0));
uint packed_edge_fac = a << 24 | b << 16 | c << 8 | d;
output_edge_fac[index] = packed_edge_fac;
#endif
}
/* From extract_mesh_vbo_edge_fac.cc, keep in sync! */
float loop_edge_factor_get(vec3 f_no, vec3 v_co, vec3 v_no, vec3 v_next_co)
{
vec3 evec = v_next_co - v_co;
vec3 enor = normalize(cross(v_no, evec));
float d = abs(dot(enor, f_no));
/* Re-scale to the slider range. */
d *= (1.0 / 0.065);
return clamp(d, 0.0, 1.0);
}
float compute_line_factor(uint start_loop_index, uint corner_index, vec3 face_normal)
{
uint vertex_index = start_loop_index + corner_index;
uint edge_index = input_edge_index[vertex_index];
if (edge_index == -1 && optimal_display) {
return 0.0;
}
/* Mod 4 so we loop back at the first vertex on the last loop index (3), but only the corner
* index needs to be wrapped. */
uint next_vertex_index = start_loop_index + (corner_index + 1) % 4;
vec3 vertex_pos = get_vertex_pos(pos_nor[vertex_index]);
vec3 vertex_nor = get_vertex_nor(pos_nor[vertex_index]);
vec3 next_vertex_pos = get_vertex_pos(pos_nor[next_vertex_index]);
return loop_edge_factor_get(face_normal, vertex_pos, vertex_nor, next_vertex_pos);
}
void main()
{
/* We execute for each quad. */
uint quad_index = get_global_invocation_index();
if (quad_index >= total_dispatch_size) {
return;
}
/* The start index of the loop is quad_index * 4. */
uint start_loop_index = quad_index * 4;
/* First compute the face normal, we need it to compute the bihedral edge angle. */
vec3 v0 = get_vertex_pos(pos_nor[start_loop_index + 0]);
vec3 v1 = get_vertex_pos(pos_nor[start_loop_index + 1]);
vec3 v2 = get_vertex_pos(pos_nor[start_loop_index + 2]);
vec3 face_normal = normalize(cross(v1 - v0, v2 - v0));
vec4 edge_facs = vec4(0.0);
for (int i = 0; i < 4; i++) {
edge_facs[i] = compute_line_factor(start_loop_index, i, face_normal);
}
#ifdef GPU_AMD_DRIVER_BYTE_BUG
write_vec4(start_loop_index, edge_facs);
#else
/* When packed into bytes, the index is the same as for the quad. */
write_vec4(quad_index, edge_facs);
#endif
}
|
