Fix T55165: Driving camera lens with property behaves unexpectedly
[blender.git] / source / blender / modifiers / intern / MOD_uvproject.c
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) 2005 by the Blender Foundation.
19  * All rights reserved.
20  *
21  * Contributor(s): Daniel Dunbar
22  *                 Ton Roosendaal,
23  *                 Ben Batt,
24  *                 Brecht Van Lommel,
25  *                 Campbell Barton
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  *
29  */
30
31 /** \file blender/modifiers/intern/MOD_uvproject.c
32  *  \ingroup modifiers
33  */
34
35
36 /* UV Project modifier: Generates UVs projected from an object */
37
38 #include "DNA_mesh_types.h"
39 #include "DNA_meshdata_types.h"
40 #include "DNA_camera_types.h"
41 #include "DNA_object_types.h"
42
43 #include "BLI_math.h"
44 #include "BLI_uvproject.h"
45 #include "BLI_utildefines.h"
46
47
48 #include "BKE_camera.h"
49 #include "BKE_library.h"
50 #include "BKE_library_query.h"
51 #include "BKE_material.h"
52 #include "BKE_mesh.h"
53
54 #include "MOD_modifiertypes.h"
55
56 #include "MEM_guardedalloc.h"
57
58 #include "DEG_depsgraph.h"
59 #include "DEG_depsgraph_build.h"
60 #include "DEG_depsgraph_query.h"
61
62 static void initData(ModifierData *md)
63 {
64         UVProjectModifierData *umd = (UVProjectModifierData *) md;
65
66
67         umd->num_projectors = 1;
68         umd->aspectx = umd->aspecty = 1.0f;
69         umd->scalex = umd->scaley = 1.0f;
70 }
71
72 static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *UNUSED(md))
73 {
74         CustomDataMask dataMask = 0;
75
76         /* ask for UV coordinates */
77         dataMask |= CD_MLOOPUV;
78
79         return dataMask;
80 }
81
82 static void foreachObjectLink(
83         ModifierData *md, Object *ob,
84         ObjectWalkFunc walk, void *userData)
85 {
86         UVProjectModifierData *umd = (UVProjectModifierData *) md;
87         int i;
88
89         for (i = 0; i < MOD_UVPROJECT_MAXPROJECTORS; ++i)
90                 walk(userData, ob, &umd->projectors[i], IDWALK_CB_NOP);
91 }
92
93 static void foreachIDLink(
94         ModifierData *md, Object *ob,
95         IDWalkFunc walk, void *userData)
96 {
97 #if 0
98         UVProjectModifierData *umd = (UVProjectModifierData *) md;
99 #endif
100
101         foreachObjectLink(md, ob, (ObjectWalkFunc)walk, userData);
102 }
103
104 static void updateDepsgraph(ModifierData *md, const ModifierUpdateDepsgraphContext *ctx)
105 {
106         UVProjectModifierData *umd = (UVProjectModifierData *)md;
107         int i;
108         for (i = 0; i < umd->num_projectors; ++i) {
109                 if (umd->projectors[i] != NULL) {
110                         DEG_add_object_relation(ctx->node, umd->projectors[i], DEG_OB_COMP_TRANSFORM, "UV Project Modifier");
111                 }
112         }
113 }
114
115 typedef struct Projector {
116         Object *ob_eval;             /* object this projector is derived from */
117         float projmat[4][4];    /* projection matrix */
118         float normal[3];        /* projector normal in world space */
119         void *uci;              /* optional uv-project info (panorama projection) */
120 } Projector;
121
122 static Mesh *uvprojectModifier_do(
123         UVProjectModifierData *umd,
124         Depsgraph *depsgraph,
125         Object *ob, Mesh *mesh)
126 {
127         float (*coords)[3], (*co)[3];
128         MLoopUV *mloop_uv;
129         int i, numVerts, numPolys, numLoops;
130         MPoly *mpoly, *mp;
131         MLoop *mloop;
132         Projector projectors[MOD_UVPROJECT_MAXPROJECTORS];
133         int num_projectors = 0;
134         char uvname[MAX_CUSTOMDATA_LAYER_NAME];
135         float aspx = umd->aspectx ? umd->aspectx : 1.0f;
136         float aspy = umd->aspecty ? umd->aspecty : 1.0f;
137         float scax = umd->scalex ? umd->scalex : 1.0f;
138         float scay = umd->scaley ? umd->scaley : 1.0f;
139         int free_uci = 0;
140
141         for (i = 0; i < umd->num_projectors; ++i)
142                 if (umd->projectors[i])
143                         projectors[num_projectors++].ob_eval = DEG_get_evaluated_object(depsgraph, umd->projectors[i]);
144
145         if (num_projectors == 0) return mesh;
146
147         /* make sure there are UV Maps available */
148
149         if (!CustomData_has_layer(&mesh->ldata, CD_MLOOPUV)) return mesh;
150
151         /* make sure we're using an existing layer */
152         CustomData_validate_layer_name(&mesh->ldata, CD_MLOOPUV, umd->uvlayer_name, uvname);
153
154         /* calculate a projection matrix and normal for each projector */
155         for (i = 0; i < num_projectors; ++i) {
156                 float tmpmat[4][4];
157                 float offsetmat[4][4];
158                 Camera *cam = NULL;
159                 /* calculate projection matrix */
160                 invert_m4_m4(projectors[i].projmat, projectors[i].ob_eval->obmat);
161
162                 projectors[i].uci = NULL;
163
164                 if (projectors[i].ob_eval->type == OB_CAMERA) {
165                         cam = (Camera *)projectors[i].ob_eval->data;
166                         if (cam->type == CAM_PANO) {
167                                 projectors[i].uci = BLI_uvproject_camera_info(projectors[i].ob_eval, NULL, aspx, aspy);
168                                 BLI_uvproject_camera_info_scale(projectors[i].uci, scax, scay);
169                                 free_uci = 1;
170                         }
171                         else {
172                                 CameraParams params;
173
174                                 /* setup parameters */
175                                 BKE_camera_params_init(&params);
176                                 BKE_camera_params_from_object(&params, projectors[i].ob_eval);
177
178                                 /* compute matrix, viewplane, .. */
179                                 BKE_camera_params_compute_viewplane(&params, 1, 1, aspx, aspy);
180
181                                 /* scale the view-plane */
182                                 params.viewplane.xmin *= scax;
183                                 params.viewplane.xmax *= scax;
184                                 params.viewplane.ymin *= scay;
185                                 params.viewplane.ymax *= scay;
186
187                                 BKE_camera_params_compute_matrix(&params);
188                                 mul_m4_m4m4(tmpmat, params.winmat, projectors[i].projmat);
189                         }
190                 }
191                 else {
192                         copy_m4_m4(tmpmat, projectors[i].projmat);
193                 }
194
195                 unit_m4(offsetmat);
196                 mul_mat3_m4_fl(offsetmat, 0.5);
197                 offsetmat[3][0] = offsetmat[3][1] = offsetmat[3][2] = 0.5;
198
199                 mul_m4_m4m4(projectors[i].projmat, offsetmat, tmpmat);
200
201                 /* calculate worldspace projector normal (for best projector test) */
202                 projectors[i].normal[0] = 0;
203                 projectors[i].normal[1] = 0;
204                 projectors[i].normal[2] = 1;
205                 mul_mat3_m4_v3(projectors[i].ob_eval->obmat, projectors[i].normal);
206         }
207
208         numPolys = mesh->totpoly;
209         numLoops = mesh->totloop;
210
211         /* make sure we are not modifying the original UV map */
212         mloop_uv = CustomData_duplicate_referenced_layer_named(&mesh->ldata,
213                                                                CD_MLOOPUV, uvname, numLoops);
214
215         coords = BKE_mesh_vertexCos_get(mesh, &numVerts);
216
217         /* convert coords to world space */
218         for (i = 0, co = coords; i < numVerts; ++i, ++co)
219                 mul_m4_v3(ob->obmat, *co);
220         
221         /* if only one projector, project coords to UVs */
222         if (num_projectors == 1 && projectors[0].uci == NULL)
223                 for (i = 0, co = coords; i < numVerts; ++i, ++co)
224                         mul_project_m4_v3(projectors[0].projmat, *co);
225
226         mpoly = mesh->mpoly;
227         mloop = mesh->mloop;
228
229         /* apply coords as UVs */
230         for (i = 0, mp = mpoly; i < numPolys; ++i, ++mp) {
231                 if (num_projectors == 1) {
232                         if (projectors[0].uci) {
233                                 unsigned int fidx = mp->totloop - 1;
234                                 do {
235                                         unsigned int lidx = mp->loopstart + fidx;
236                                         unsigned int vidx = mloop[lidx].v;
237                                         BLI_uvproject_from_camera(mloop_uv[lidx].uv, coords[vidx], projectors[0].uci);
238                                 } while (fidx--);
239                         }
240                         else {
241                                 /* apply transformed coords as UVs */
242                                 unsigned int fidx = mp->totloop - 1;
243                                 do {
244                                         unsigned int lidx = mp->loopstart + fidx;
245                                         unsigned int vidx = mloop[lidx].v;
246                                         copy_v2_v2(mloop_uv[lidx].uv, coords[vidx]);
247                                 } while (fidx--);
248                         }
249                 }
250                 else {
251                         /* multiple projectors, select the closest to face normal direction */
252                         float face_no[3];
253                         int j;
254                         Projector *best_projector;
255                         float best_dot;
256
257                         /* get the untransformed face normal */
258                         BKE_mesh_calc_poly_normal_coords(mp, mloop + mp->loopstart, (const float (*)[3])coords, face_no);
259
260                         /* find the projector which the face points at most directly
261                          * (projector normal with largest dot product is best)
262                          */
263                         best_dot = dot_v3v3(projectors[0].normal, face_no);
264                         best_projector = &projectors[0];
265
266                         for (j = 1; j < num_projectors; ++j) {
267                                 float tmp_dot = dot_v3v3(projectors[j].normal, face_no);
268                                 if (tmp_dot > best_dot) {
269                                         best_dot = tmp_dot;
270                                         best_projector = &projectors[j];
271                                 }
272                         }
273
274                         if (best_projector->uci) {
275                                 unsigned int fidx = mp->totloop - 1;
276                                 do {
277                                         unsigned int lidx = mp->loopstart + fidx;
278                                         unsigned int vidx = mloop[lidx].v;
279                                         BLI_uvproject_from_camera(mloop_uv[lidx].uv, coords[vidx], best_projector->uci);
280                                 } while (fidx--);
281                         }
282                         else {
283                                 unsigned int fidx = mp->totloop - 1;
284                                 do {
285                                         unsigned int lidx = mp->loopstart + fidx;
286                                         unsigned int vidx = mloop[lidx].v;
287                                         mul_v2_project_m4_v3(mloop_uv[lidx].uv, best_projector->projmat, coords[vidx]);
288                                 } while (fidx--);
289                         }
290                 }
291         }
292
293         MEM_freeN(coords);
294
295         if (free_uci) {
296                 int j;
297                 for (j = 0; j < num_projectors; ++j) {
298                         if (projectors[j].uci) {
299                                 MEM_freeN(projectors[j].uci);
300                         }
301                 }
302         }
303
304         /* Mark tessellated CD layers as dirty. */
305         mesh->runtime.cd_dirty_vert |= CD_MASK_TESSLOOPNORMAL;
306
307         return mesh;
308 }
309
310 static Mesh *applyModifier(
311         ModifierData *md, const ModifierEvalContext *ctx,
312         Mesh *mesh)
313 {
314         Mesh *result;
315         UVProjectModifierData *umd = (UVProjectModifierData *) md;
316
317         result = uvprojectModifier_do(umd, ctx->depsgraph, ctx->object, mesh);
318
319         return result;
320 }
321
322
323 ModifierTypeInfo modifierType_UVProject = {
324         /* name */              "UVProject",
325         /* structName */        "UVProjectModifierData",
326         /* structSize */        sizeof(UVProjectModifierData),
327         /* type */              eModifierTypeType_NonGeometrical,
328         /* flags */             eModifierTypeFlag_AcceptsMesh |
329                                 eModifierTypeFlag_SupportsMapping |
330                                 eModifierTypeFlag_SupportsEditmode |
331                                 eModifierTypeFlag_EnableInEditmode,
332
333         /* copyData */          modifier_copyData_generic,
334
335         /* deformVerts_DM */    NULL,
336         /* deformMatrices_DM */ NULL,
337         /* deformVertsEM_DM */  NULL,
338         /* deformMatricesEM_DM*/NULL,
339         /* applyModifier_DM */  NULL,
340         /* applyModifierEM_DM */NULL,
341
342         /* deformVerts */       NULL,
343         /* deformMatrices */    NULL,
344         /* deformVertsEM */     NULL,
345         /* deformMatricesEM */  NULL,
346         /* applyModifier */     applyModifier,
347         /* applyModifierEM */   NULL,
348
349         /* initData */          initData,
350         /* requiredDataMask */  requiredDataMask,
351         /* freeData */          NULL,
352         /* isDisabled */        NULL,
353         /* updateDepsgraph */   updateDepsgraph,
354         /* dependsOnTime */     NULL,
355         /* dependsOnNormals */  NULL,
356         /* foreachObjectLink */ foreachObjectLink,
357         /* foreachIDLink */     foreachIDLink,
358         /* foreachTexLink */    NULL,
359 };