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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
|
/* SPDX-License-Identifier: GPL-2.0-or-later
* Copyright 2021 Blender Foundation. */
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#include "BLI_sys_types.h"
struct BMesh;
struct GPUIndexBuf;
struct GPUUniformBuf;
struct GPUVertBuf;
struct Mesh;
struct MeshBatchCache;
struct MeshBufferCache;
struct MeshRenderData;
struct Object;
struct Scene;
struct Subdiv;
struct ToolSettings;
/* -------------------------------------------------------------------- */
/** \name DRWPatchMap
*
* This is a GPU version of the OpenSubDiv PatchMap. The quad tree and the patch handles are copied
* to GPU buffers in order to lookup the right patch for a given set of patch coordinates.
* \{ */
typedef struct DRWPatchMap {
struct GPUVertBuf *patch_map_handles;
struct GPUVertBuf *patch_map_quadtree;
int min_patch_face;
int max_patch_face;
int max_depth;
int patches_are_triangular;
} DRWPatchMap;
/** \} */
/* -------------------------------------------------------------------- */
/** \name DRWSubdivCache
*
* This holds the various buffers used to evaluate and render subdivision through OpenGL.
* \{ */
typedef struct DRWSubdivCache {
struct Mesh *mesh;
struct BMesh *bm;
struct Subdiv *subdiv;
bool optimal_display;
bool use_custom_loop_normals;
/* Coordinates used to evaluate patches for UVs, positions, and normals. */
struct GPUVertBuf *patch_coords;
/* Coordinates used to evaluate patches for the face centers (or face dots) in edit-mode. */
struct GPUVertBuf *fdots_patch_coords;
/* Resolution used to generate the patch coordinates. */
int resolution;
/* Number of subdivided loops, also the number of patch coordinates since we have one coordinate
* but quad corner/vertex. */
uint num_subdiv_loops;
uint num_subdiv_edges;
uint num_subdiv_triangles;
uint num_subdiv_verts;
uint num_subdiv_quads;
/* Number of polygons in the coarse mesh, notably used to compute a coarse polygon index given a
* subdivision loop index. */
int num_coarse_poly;
/* Maps subdivision loop to subdivided vertex index. */
int *subdiv_loop_subdiv_vert_index;
/* Maps subdivision loop to original coarse poly index. */
int *subdiv_loop_poly_index;
/* Indices of faces adjacent to the vertices, ordered by vertex index, with no particular
* winding. */
struct GPUVertBuf *subdiv_vertex_face_adjacency;
/* The difference between value (i + 1) and (i) gives the number of faces adjacent to vertex (i).
*/
struct GPUVertBuf *subdiv_vertex_face_adjacency_offsets;
/* Maps subdivision loop to original coarse vertex index, only really useful for edit mode. */
struct GPUVertBuf *verts_orig_index;
/* Maps subdivision loop to original coarse edge index, only really useful for edit mode. */
struct GPUVertBuf *edges_orig_index;
/* Owned by #Subdiv. Indexed by coarse polygon index, difference between value (i + 1) and (i)
* gives the number of ptex faces for coarse polygon (i). */
int *face_ptex_offset;
/* Vertex buffer for face_ptex_offset. */
struct GPUVertBuf *face_ptex_offset_buffer;
int *subdiv_polygon_offset;
struct GPUVertBuf *subdiv_polygon_offset_buffer;
/* Contains the start loop index and the smooth flag for each coarse polygon. */
struct GPUVertBuf *extra_coarse_face_data;
/* Computed for ibo.points, one value per subdivided vertex, mapping coarse vertices ->
* subdivided loop */
int *point_indices;
/* Material offsets. */
int *mat_start;
int *mat_end;
struct GPUVertBuf *polygon_mat_offset;
DRWPatchMap gpu_patch_map;
/* UBO to store settings for the various compute shaders. */
struct GPUUniformBuf *ubo;
} DRWSubdivCache;
/* Only frees the data of the cache, caller is responsible to free the cache itself if necessary.
*/
void draw_subdiv_cache_free(DRWSubdivCache *cache);
/** \} */
void DRW_create_subdivision(const struct Scene *scene,
struct Object *ob,
struct Mesh *mesh,
struct MeshBatchCache *batch_cache,
struct MeshBufferCache *mbc,
const bool is_editmode,
const bool is_paint_mode,
const bool is_mode_active,
const float obmat[4][4],
const bool do_final,
const bool do_uvedit,
const bool use_subsurf_fdots,
const ToolSettings *ts,
const bool use_hide);
void DRW_subdivide_loose_geom(DRWSubdivCache *subdiv_cache, struct MeshBufferCache *cache);
void DRW_subdiv_cache_free(struct Subdiv *subdiv);
void draw_subdiv_init_mesh_render_data(DRWSubdivCache *cache,
struct MeshRenderData *mr,
const struct ToolSettings *toolsettings);
void draw_subdiv_init_origindex_buffer(struct GPUVertBuf *buffer,
int *vert_origindex,
uint num_loops,
uint loose_len);
struct GPUVertBuf *draw_subdiv_build_origindex_buffer(int *vert_origindex, uint num_loops);
/* Compute shader functions. */
void draw_subdiv_build_sculpt_data_buffer(const DRWSubdivCache *cache,
struct GPUVertBuf *mask_vbo,
struct GPUVertBuf *face_set_vbo,
struct GPUVertBuf *sculpt_data);
void draw_subdiv_accumulate_normals(const DRWSubdivCache *cache,
struct GPUVertBuf *pos_nor,
struct GPUVertBuf *face_adjacency_offsets,
struct GPUVertBuf *face_adjacency_lists,
struct GPUVertBuf *vertex_loop_map,
struct GPUVertBuf *vertex_normals);
void draw_subdiv_finalize_normals(const DRWSubdivCache *cache,
struct GPUVertBuf *vertex_normals,
struct GPUVertBuf *subdiv_loop_subdiv_vert_index,
struct GPUVertBuf *pos_nor);
void draw_subdiv_finalize_custom_normals(const DRWSubdivCache *cache,
GPUVertBuf *src_custom_normals,
GPUVertBuf *pos_nor);
void draw_subdiv_extract_pos_nor(const DRWSubdivCache *cache, struct GPUVertBuf *pos_nor);
void draw_subdiv_interp_custom_data(const DRWSubdivCache *cache,
struct GPUVertBuf *src_data,
struct GPUVertBuf *dst_data,
int dimensions,
int dst_offset,
bool compress_to_u16);
void draw_subdiv_extract_uvs(const DRWSubdivCache *cache,
struct GPUVertBuf *uvs,
int face_varying_channel,
int dst_offset);
void draw_subdiv_build_edge_fac_buffer(const DRWSubdivCache *cache,
struct GPUVertBuf *pos_nor,
struct GPUVertBuf *edge_idx,
struct GPUVertBuf *edge_fac);
void draw_subdiv_build_tris_buffer(const DRWSubdivCache *cache,
struct GPUIndexBuf *subdiv_tris,
int material_count);
void draw_subdiv_build_lines_buffer(const DRWSubdivCache *cache,
struct GPUIndexBuf *lines_indices);
void draw_subdiv_build_lines_loose_buffer(const DRWSubdivCache *cache,
struct GPUIndexBuf *lines_indices,
uint num_loose_edges);
void draw_subdiv_build_fdots_buffers(const DRWSubdivCache *cache,
struct GPUVertBuf *fdots_pos,
struct GPUVertBuf *fdots_nor,
struct GPUIndexBuf *fdots_indices);
void draw_subdiv_build_lnor_buffer(const DRWSubdivCache *cache,
struct GPUVertBuf *pos_nor,
struct GPUVertBuf *lnor);
void draw_subdiv_build_edituv_stretch_area_buffer(const DRWSubdivCache *cache,
struct GPUVertBuf *coarse_data,
struct GPUVertBuf *subdiv_data);
void draw_subdiv_build_edituv_stretch_angle_buffer(const DRWSubdivCache *cache,
struct GPUVertBuf *pos_nor,
struct GPUVertBuf *uvs,
int uvs_offset,
struct GPUVertBuf *stretch_angles);
#ifdef __cplusplus
}
#endif
|
