Cleanup: style, use braces for blenkernel
[blender.git] / source / blender / blenkernel / intern / subdiv_ccg_mask.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2018 by Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include "BKE_subdiv_ccg.h"
25
26 #include "DNA_mesh_types.h"
27 #include "DNA_meshdata_types.h"
28 #include "DNA_modifier_types.h"
29 #include "DNA_object_types.h"
30
31 #include "BLI_utildefines.h"
32
33 #include "BKE_customdata.h"
34 #include "BKE_subdiv.h"
35
36 #include "MEM_guardedalloc.h"
37
38 typedef struct PolyCornerIndex {
39   int poly_index;
40   int corner;
41 } PolyCornerIndex;
42
43 typedef struct GridPaintMaskData {
44   // int grid_size;
45   const MPoly *mpoly;
46   const GridPaintMask *grid_paint_mask;
47   /* Indexed by ptex face index, contains polygon/corner which corresponds
48    * to it.
49    *
50    * NOTE: For quad polygon this is an index of first corner only, since
51    * there we only have one ptex.
52    */
53   PolyCornerIndex *ptex_poly_corner;
54 } GridPaintMaskData;
55
56 static int mask_get_grid_and_coord(SubdivCCGMaskEvaluator *mask_evaluator,
57                                    const int ptex_face_index,
58                                    const float u,
59                                    const float v,
60                                    const GridPaintMask **r_mask_grid,
61                                    float *grid_u,
62                                    float *grid_v)
63 {
64   GridPaintMaskData *data = mask_evaluator->user_data;
65   const PolyCornerIndex *poly_corner = &data->ptex_poly_corner[ptex_face_index];
66   const MPoly *poly = &data->mpoly[poly_corner->poly_index];
67   const int start_grid_index = poly->loopstart + poly_corner->corner;
68   int corner = 0;
69   if (poly->totloop == 4) {
70     float corner_u, corner_v;
71     corner = BKE_subdiv_rotate_quad_to_corner(u, v, &corner_u, &corner_v);
72     *r_mask_grid = &data->grid_paint_mask[start_grid_index + corner];
73     BKE_subdiv_ptex_face_uv_to_grid_uv(corner_u, corner_v, grid_u, grid_v);
74   }
75   else {
76     *r_mask_grid = &data->grid_paint_mask[start_grid_index];
77     BKE_subdiv_ptex_face_uv_to_grid_uv(u, v, grid_u, grid_v);
78   }
79   return corner;
80 }
81
82 BLI_INLINE float read_mask_grid(const GridPaintMask *mask_grid,
83                                 const float grid_u,
84                                 const float grid_v)
85 {
86   if (mask_grid->data == NULL) {
87     return 0;
88   }
89   const int grid_size = BKE_subdiv_grid_size_from_level(mask_grid->level);
90   const int x = (grid_u * (grid_size - 1) + 0.5f);
91   const int y = (grid_v * (grid_size - 1) + 0.5f);
92   return mask_grid->data[y * grid_size + x];
93 }
94
95 static float eval_mask(SubdivCCGMaskEvaluator *mask_evaluator,
96                        const int ptex_face_index,
97                        const float u,
98                        const float v)
99 {
100   const GridPaintMask *mask_grid;
101   float grid_u, grid_v;
102   mask_get_grid_and_coord(mask_evaluator, ptex_face_index, u, v, &mask_grid, &grid_u, &grid_v);
103   return read_mask_grid(mask_grid, grid_u, grid_v);
104 }
105
106 static void free_mask_data(SubdivCCGMaskEvaluator *mask_evaluator)
107 {
108   GridPaintMaskData *data = mask_evaluator->user_data;
109   MEM_freeN(data->ptex_poly_corner);
110   MEM_freeN(data);
111 }
112
113 /* TODO(sergey): This seems to be generally used information, which almost
114  * worth adding to a subdiv itself, with possible cache of the value.
115  */
116 static int count_num_ptex_faces(const Mesh *mesh)
117 {
118   int num_ptex_faces = 0;
119   const MPoly *mpoly = mesh->mpoly;
120   for (int poly_index = 0; poly_index < mesh->totpoly; poly_index++) {
121     const MPoly *poly = &mpoly[poly_index];
122     num_ptex_faces += (poly->totloop == 4) ? 1 : poly->totloop;
123   }
124   return num_ptex_faces;
125 }
126
127 static void mask_data_init_mapping(SubdivCCGMaskEvaluator *mask_evaluator, const Mesh *mesh)
128 {
129   GridPaintMaskData *data = mask_evaluator->user_data;
130   const MPoly *mpoly = mesh->mpoly;
131   const int num_ptex_faces = count_num_ptex_faces(mesh);
132   /* Allocate memory. */
133   data->ptex_poly_corner = MEM_malloc_arrayN(
134       num_ptex_faces, sizeof(*data->ptex_poly_corner), "ptex poly corner");
135   /* Fill in offsets. */
136   int ptex_face_index = 0;
137   PolyCornerIndex *ptex_poly_corner = data->ptex_poly_corner;
138   for (int poly_index = 0; poly_index < mesh->totpoly; poly_index++) {
139     const MPoly *poly = &mpoly[poly_index];
140     if (poly->totloop == 4) {
141       ptex_poly_corner[ptex_face_index].poly_index = poly_index;
142       ptex_poly_corner[ptex_face_index].corner = 0;
143       ptex_face_index++;
144     }
145     else {
146       for (int corner = 0; corner < poly->totloop; corner++) {
147         ptex_poly_corner[ptex_face_index].poly_index = poly_index;
148         ptex_poly_corner[ptex_face_index].corner = corner;
149         ptex_face_index++;
150       }
151     }
152   }
153 }
154
155 static void mask_init_data(SubdivCCGMaskEvaluator *mask_evaluator, const Mesh *mesh)
156 {
157   GridPaintMaskData *data = mask_evaluator->user_data;
158   data->mpoly = mesh->mpoly;
159   data->grid_paint_mask = CustomData_get_layer(&mesh->ldata, CD_GRID_PAINT_MASK);
160   mask_data_init_mapping(mask_evaluator, mesh);
161 }
162
163 static void mask_init_functions(SubdivCCGMaskEvaluator *mask_evaluator)
164 {
165   mask_evaluator->eval_mask = eval_mask;
166   mask_evaluator->free = free_mask_data;
167 }
168
169 bool BKE_subdiv_ccg_mask_init_from_paint(SubdivCCGMaskEvaluator *mask_evaluator,
170                                          const struct Mesh *mesh)
171 {
172   GridPaintMask *grid_paint_mask = CustomData_get_layer(&mesh->ldata, CD_GRID_PAINT_MASK);
173   if (grid_paint_mask == NULL) {
174     return false;
175   }
176   /* Allocate all required memory. */
177   mask_evaluator->user_data = MEM_callocN(sizeof(GridPaintMaskData), "mask from grid data");
178   mask_init_data(mask_evaluator, mesh);
179   mask_init_functions(mask_evaluator);
180   return true;
181 }