Physically based defaults for Eevee Bloom and Shutter
[blender.git] / source / blender / blenkernel / BKE_subdiv_ccg.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2018 by Blender Foundation.
19  * All rights reserved.
20  *
21  * Contributor(s): Sergey Sharybin.
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file BKE_subdiv_ccg.h
27  *  \ingroup bke
28  *  \since July 2018
29  *  \author Sergey Sharybin
30  */
31
32 #ifndef __BKE_SUBDIV_CCG_H__
33 #define __BKE_SUBDIV_CCG_H__
34
35 #include "BKE_customdata.h"
36 #include "BLI_bitmap.h"
37 #include "BLI_sys_types.h"
38
39 struct CCGElem;
40 struct CCGFace;
41 struct CCGKey;
42 struct DMFlagMat;
43 struct Mesh;
44 struct Subdiv;
45
46 /* =============================================================================
47  * Masks.
48  */
49
50 /* Functor which evaluates mask value at a given (u, v) of given ptex face. */
51 typedef struct SubdivCCGMask {
52         float (*eval_mask)(struct SubdivCCGMask *mask,
53                            const int ptex_face_index,
54                            const float u, const float v);
55
56         /* Free the data, not the evaluator itself. */
57         void (*free)(struct SubdivCCGMask *mask);
58
59         void *user_data;
60 } SubdivCCGMask;
61
62 /* Return true if mesh has mask and evaluator can be used. */
63 bool BKE_subdiv_ccg_mask_init_from_paint(
64         SubdivCCGMask *mask_evaluator,
65         const struct Mesh *mesh);
66
67 /* =============================================================================
68  * SubdivCCG.
69  */
70
71 typedef struct SubdivToCCGSettings {
72         /* Resolution at which regular ptex (created for quad polygon) are being
73          * evaluated. This defines how many vertices final mesh will have: every
74          * regular ptex has resolution^2 vertices. Special (irregular, or ptex
75          * created for a corner of non-quad polygon) will have resolution of
76          * `resolution - 1`.
77          */
78         int resolution;
79         /* Denotes which extra layers to be added to CCG elements. */
80         bool need_normal;
81         bool need_mask;
82 } SubdivToCCGSettings;
83
84 /* This is actually a coarse face, which consists of multiple CCG grids. */
85 typedef struct SubdivCCGFace {
86         /* Total number of grids in this face.
87          *
88          * This 1:1 corresponds to a number of corners (or loops) from a coarse
89          * face.
90          */
91         int num_grids;
92         /* Index of first grid from this face in SubdivCCG->grids array. */
93         int start_grid_index;
94 } SubdivCCGFace;
95
96 /* Definition of an edge which is adjacent to at least one of the faces. */
97 typedef struct SubdivCCGAdjacentEdge {
98         int num_adjacent_faces;
99         /* Indexed by adjacent face index. */
100         SubdivCCGFace **faces;
101         /* Indexed by adjacent face index, then by point index on the edge.
102          * points to a grid element.
103          */
104         struct CCGElem ***boundary_elements;
105 } SubdivCCGAdjacentEdge;
106
107 /* Definition of a vertex which is adjacent to at least one of the faces. */
108 typedef struct SubdivCCGAdjacentVertex {
109         int num_adjacent_faces;
110         /* Indexed by adjacent face index. */
111         SubdivCCGFace **faces;
112         /* Indexed by adjacent face index, points to a grid element.
113          */
114         struct CCGElem **corner_elements;
115 } SubdivCCGAdjacentVertex;
116
117 /* Representation of subdivision surface which uses CCG grids. */
118 typedef struct SubdivCCG {
119         /* This is a subdivision surface this CCG was created for.
120          *
121          * TODO(sergey): Make sure the whole descriptor is valid, including all the
122          * displacement attached to the surface.
123          */
124         struct Subdiv *subdiv;
125         /* A level at which geometry was subdivided. This is what defines grid
126          * resolution. It is NOT the topology refinement level.
127          */
128         int level;
129         /* Resolution of grid. All grids have matching resolution, and resolution
130          * is same as ptex created for non-quad polygons.
131          */
132         int grid_size;
133         /* Grids represent limit surface, with displacement applied. Grids are
134          * corresponding to face-corners of coarse mesh, each grid has
135          * grid_size^2 elements.
136          */
137         /* Indexed by a grid index, points to a grid data which is stored in
138          * grids_storage.
139          */
140         struct CCGElem **grids;
141         /* Flat array of all grids' data. */
142         unsigned char *grids_storage;
143         int num_grids;
144         /* Loose edges, each array element contains grid_size elements
145          * corresponding to vertices created by subdividing coarse edges.
146          */
147         struct CCGElem **edges;
148         int num_edges;
149         /* Loose vertices. Every element corresponds to a loose vertex from a coarse
150          * mesh, every coarse loose vertex corresponds to a single sundivided
151          * element.
152          */
153         struct CCGElem *vertices;
154         int num_vertices;
155         /* Denotes which layers present in the elements.
156          *
157          * Grids always has coordinates, followed by extra layers which are set to
158          * truth here.
159          */
160         bool has_normal;
161         bool has_mask;
162         /* Offsets of corresponding data layers in the elements. */
163         int normal_offset;
164         int mask_offset;
165
166         /* Faces from which grids are emitted. */
167         int num_faces;
168         SubdivCCGFace *faces;
169         /* Indexed by grid index, points to corresponding face from `faces`. */
170         SubdivCCGFace **grid_faces;
171
172         /* Edges which are adjacent to faces.
173          * Used for faster grid stitching, in the cost of extra memory.
174          */
175         int num_adjacent_edges;
176         SubdivCCGAdjacentEdge *adjacent_edges;
177
178         /* Vertices which are adjacent to faces
179          * Used for faster grid stitching, in the cost of extra memory.
180          */
181         int num_adjacent_vertices;
182         SubdivCCGAdjacentVertex *adjacent_vertices;
183
184         struct DMFlagMat *grid_flag_mats;
185         BLI_bitmap **grid_hidden;
186
187         /* TODO(sergey): Consider adding some accessors to a "decoded" geometry,
188          * to make integration with draw manager and such easy.
189          */
190
191         /* TODO(sergey): Consider adding CD layers here, so we can draw final mesh
192          * from grids, and have UVs and such work.
193          */
194
195         /* Integration with sculpting. */
196         /* TODO(sergey): Is this really best way to go? Kind of annoying to have
197          * such use-related flags in a more or less generic structure.
198          */
199         struct {
200                 /* Corresponds to MULTIRES_COORDS_MODIFIED. */
201                 bool coords;
202                 /* Corresponds to MULTIRES_HIDDEN_MODIFIED. */
203                 bool hidden;
204         } dirty;
205 } SubdivCCG;
206
207 /* Create real hi-res CCG from subdivision.
208  *
209  * NOTE: Subdiv is expected to be refined and ready for evaluation.
210  * NOTE: CCG becomes an owner of subdiv.
211  *
212  * TODO(sergey): Allow some user-counter or more explicit control over who owns
213  * the Subdiv. The goal should be to allow viewport GL Mesh and CCG to share
214  * same Subsurf without conflicts.
215  */
216 struct SubdivCCG *BKE_subdiv_to_ccg(
217         struct Subdiv *subdiv,
218         const SubdivToCCGSettings *settings,
219         SubdivCCGMask *mask_evaluator);
220
221 /* Destroy CCG representation of subdivision surface. */
222 void BKE_subdiv_ccg_destroy(SubdivCCG *subdiv_ccg);
223
224 /* Helper function, creates Mesh structure which is properly setup to use
225  * grids.
226  */
227 struct Mesh *BKE_subdiv_to_ccg_mesh(
228         struct Subdiv *subdiv,
229         const SubdivToCCGSettings *settings,
230         const struct Mesh *coarse_mesh);
231
232 /* Create a key for accessing grid elements at a given level. */
233 void BKE_subdiv_ccg_key(
234         struct CCGKey *key, const SubdivCCG *subdiv_ccg, int level);
235 void BKE_subdiv_ccg_key_top_level(
236         struct CCGKey *key, const SubdivCCG *subdiv_ccg);
237
238 /* Recalculate all normals based on grid element coordinates. */
239 void BKE_subdiv_ccg_recalc_normals(SubdivCCG *subdiv_ccg);
240
241 /* Average grid coordinates and normals along the grid boundatries. */
242 void BKE_subdiv_ccg_average_grids(SubdivCCG *subdiv_ccg);
243
244 /* Similar to above, but only updates given faces. */
245 void BKE_subdiv_ccg_average_stitch_faces(SubdivCCG *subdiv_ccg,
246                                          struct CCGFace **effected_faces,
247                                          int num_effected_faces);
248
249 /* Get geometry counters at the current subdivision level. */
250 void BKE_subdiv_ccg_topology_counters(
251         const SubdivCCG *subdiv_ccg,
252         int *r_num_vertices, int *r_num_edges,
253         int *r_num_faces, int *r_num_loops);
254
255 #endif  /* __BKE_SUBDIV_CCG_H__ */