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