69e2caaf12e1cf779b5612fb3da2952eb6b465fe
[blender.git] / source / blender / src / multires.c
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software  Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2006 by Nicholas Bishop
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): none yet.
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  *
29  * Implements the multiresolution modeling tools.
30  *
31  * multires.h
32  *
33  */
34
35 #include "MEM_guardedalloc.h"
36
37 #include "BLI_blenlib.h"
38 #include "BLI_arithb.h"
39
40 #include "DNA_key_types.h"
41 #include "DNA_mesh_types.h"
42 #include "DNA_meshdata_types.h"
43 #include "DNA_modifier_types.h"
44 #include "DNA_object_types.h"
45 #include "DNA_scene_types.h"
46 #include "DNA_vec_types.h"
47 #include "DNA_view3d_types.h"
48
49 #include "BKE_customdata.h"
50 #include "BKE_depsgraph.h"
51 #include "BKE_global.h"
52 #include "BKE_key.h"
53 #include "BKE_mesh.h"
54 #include "BKE_modifier.h"
55 #include "BKE_multires.h"
56 #include "BKE_object.h"
57
58 #include "BIF_editmesh.h"
59 #include "BIF_screen.h"
60 #include "BIF_space.h"
61 #include "BIF_toolbox.h"
62
63 #include "BDR_editobject.h"
64 #include "BDR_sculptmode.h"
65
66 #include "BLI_editVert.h"
67
68 #include "BSE_edit.h"
69 #include "BSE_view.h"
70
71 #include "IMB_imbuf.h"
72 #include "IMB_imbuf_types.h"
73
74 #include "blendef.h"
75 #include "editmesh.h"
76 #include "multires.h"
77 #include "mydevice.h"
78 #include "parametrizer.h"
79
80 #include <math.h>
81
82 void multires_calc_temp_data(struct MultiresLevel *lvl);
83
84 int multires_test()
85 {
86         Mesh *me= get_mesh(OBACT);
87         if(me && me->mr) {
88                 error("Unable to complete action with multires enabled.");
89                 return 1;
90         }
91         return 0;
92 }
93 int multires_level1_test()
94 {
95         Mesh *me= get_mesh(OBACT);
96         if(me && me->mr && me->mr->current != 1) {
97                 error("Operation only available for multires level 1.");
98                 return 1;
99         }
100         return 0;
101 }
102
103 /* Sculptmode */
104
105 void multires_check_state()
106 {
107         if(G.f & G_SCULPTMODE && !G.obedit)
108                 sculptmode_correct_state();
109 }
110
111 void Vec3fAvg3(float *out, float *v1, float *v2, float *v3)
112 {
113         out[0]= (v1[0]+v2[0]+v3[0])/3;
114         out[1]= (v1[1]+v2[1]+v3[1])/3;
115         out[2]= (v1[2]+v2[2]+v3[2])/3;
116 }
117 void Vec3fAvg4(float *out, float *v1, float *v2, float *v3, float *v4)
118 {
119         out[0]= (v1[0]+v2[0]+v3[0]+v4[0])/4;
120         out[1]= (v1[1]+v2[1]+v3[1]+v4[1])/4;
121         out[2]= (v1[2]+v2[2]+v3[2]+v4[2])/4;
122 }
123
124 void multires_make(void *ob, void *me_v)
125 {
126         Mesh *me= me_v;
127         Key *key;
128         
129         /* Check for shape keys */
130         key= me->key;
131         if(key) {
132                 int ret= okee("Adding multires will delete all shape keys, proceed?");
133                 if(ret) {
134                         free_key(key);
135                         me->key= NULL;
136                 } else
137                         return;
138         }
139         
140         waitcursor(1);
141         
142         multires_check_state();
143
144         multires_create(me);
145
146         allqueue(REDRAWBUTSEDIT, 0);
147         BIF_undo_push("Make multires");
148         waitcursor(0);
149 }
150
151 void multires_delete(void *ob, void *me_v)
152 {
153         Mesh *me= me_v;
154         multires_free(me->mr);
155         me->mr= NULL;
156         
157         multires_check_state();
158
159         allqueue(REDRAWBUTSEDIT, 0);
160
161         BIF_undo_push("Apply multires");
162 }
163
164 /* Make sure that all level indices are clipped to [1, mr->level_count] */
165 void multires_clip_levels(Multires *mr)
166 {
167         if(mr) {
168                 const int cnt = mr->level_count;
169         
170                 if(mr->current < 1) mr->current = 1;
171                 if(mr->edgelvl < 1) mr->edgelvl = 1;
172                 if(mr->pinlvl < 1) mr->pinlvl = 1;
173                 if(mr->renderlvl < 1) mr->renderlvl = 1;
174                 
175                 if(mr->current > cnt) mr->current = cnt;
176                 if(mr->edgelvl > cnt) mr->edgelvl = cnt;
177                 if(mr->pinlvl > cnt) mr->pinlvl = cnt;
178                 if(mr->renderlvl > cnt) mr->renderlvl = cnt;
179         }
180 }
181
182 /* Delete all multires levels beneath current level. Subdivide special
183    first-level data up to the new lowest level. */
184 void multires_del_lower(void *ob, void *me)
185 {
186         Multires *mr= ((Mesh*)me)->mr;
187         MultiresLevel *lvl1= mr->levels.first, *cr_lvl= current_level(mr);
188         MultiresLevel *lvl= NULL, *lvlprev= NULL;
189         short *edgeflags= NULL;
190         char *edgecreases= NULL;
191         int i, last;
192         
193         if(cr_lvl == lvl1) return;
194         
195         multires_check_state();
196         
197         /* Subdivide the edge flags to the current level */
198         edgeflags= MEM_callocN(sizeof(short)*current_level(mr)->totedge, "Multires Edge Flags");
199         edgecreases= MEM_callocN(sizeof(char)*current_level(mr)->totedge, "Multires Edge Creases");
200         last= lvl1->totedge * pow(2, mr->current-1);
201         for(i=0; i<last; ++i) {
202                 edgeflags[i] = mr->edge_flags[(int)(i / pow(2, mr->current-1))];
203                 edgecreases[i] = mr->edge_creases[(int)(i / pow(2, mr->current-1))];
204         }
205         MEM_freeN(mr->edge_flags);
206         MEM_freeN(mr->edge_creases);
207         mr->edge_flags= edgeflags;
208         mr->edge_creases= edgecreases;
209         
210         multires_del_lower_customdata(mr, cr_lvl);
211         
212         lvl= cr_lvl->prev;
213         while(lvl) {
214                 lvlprev= lvl->prev;
215                 
216                 multires_free_level(lvl);
217                 BLI_freelinkN(&mr->levels, lvl);
218                 
219                 mr->current-= 1;
220                 mr->level_count-= 1;
221                 
222                 lvl= lvlprev;
223         }
224         mr->newlvl= mr->current;
225         
226         multires_clip_levels(mr);
227
228         allqueue(REDRAWBUTSEDIT, 0);
229
230         BIF_undo_push("Multires delete lower");
231 }
232
233 void multires_del_higher(void *ob, void *me)
234 {
235         Multires *mr= ((Mesh*)me)->mr;
236         MultiresLevel *lvl= BLI_findlink(&mr->levels,mr->current-1);
237         MultiresLevel *lvlnext;
238         
239         multires_check_state();
240         
241         lvl= lvl->next;
242         while(lvl) {
243                 lvlnext= lvl->next;
244                 
245                 multires_free_level(lvl);
246                 BLI_freelinkN(&mr->levels,lvl);
247
248                 mr->level_count-= 1;
249                 
250                 lvl= lvlnext;
251         }
252         
253         multires_clip_levels(mr);
254
255         allqueue(REDRAWBUTSEDIT, 0);
256
257         BIF_undo_push("Multires delete higher");
258 }
259
260 static void multires_finish_mesh_update(Object *ob)
261 {
262         /* friendly check for background render */
263         if(G.background==0) {
264                 object_handle_update(ob);
265                 countall();
266                 
267                 if(G.vd && G.vd->depths) G.vd->depths->damaged= 1;
268                 allqueue(REDRAWVIEW3D, 0);
269                 allqueue(REDRAWIMAGE, 0);
270         }
271 }
272
273 void multires_subdivide(void *ob_v, void *me_v)
274 {
275         Mesh *me = me_v;
276
277         multires_check_state();
278
279         if(CustomData_number_of_layers(G.obedit ? &G.editMesh->fdata : &me->fdata, CD_MCOL) > 1) {
280                 int ret= okee("Adding a level will delete all but the active vertex color layer, proceed?");
281                 if(!ret)
282                         return;
283         }
284
285         waitcursor(1);
286         multires_add_level(ob_v, me, G.scene->toolsettings->multires_subdiv_type);
287         multires_finish_mesh_update(ob_v);
288
289         allqueue(REDRAWBUTSEDIT, 0);
290         BIF_undo_push("Add multires level");
291         waitcursor(0);
292 }
293
294 void multires_set_level_cb(void *ob, void *me)
295 {
296         waitcursor(1);
297         
298         multires_check_state();
299
300         multires_set_level(ob, me, 0);
301         multires_finish_mesh_update(ob);
302         
303         if(G.obedit || G.f & G_SCULPTMODE)
304                 BIF_undo_push("Multires set level");
305
306         allqueue(REDRAWBUTSEDIT, 0);
307         
308         waitcursor(0);
309 }
310
311 void multires_edge_level_update_cb(void *ob_v, void *me_v)
312 {
313         multires_edge_level_update(ob_v, me_v);
314         allqueue(REDRAWVIEW3D, 0);
315 }
316
317 int multires_modifier_warning()
318 {
319         ModifierData *md;
320         
321         for(md= modifiers_getVirtualModifierList(OBACT); md; md= md->next) {
322                 if(md->mode & eModifierMode_Render) {
323                         switch(md->type) {
324                         case eModifierType_Subsurf:
325                         case eModifierType_Build:
326                         case eModifierType_Mirror:
327                         case eModifierType_Decimate:
328                         case eModifierType_Boolean:
329                         case eModifierType_Array:
330                         case eModifierType_EdgeSplit:
331                                 return 1;
332                         }
333                 }
334         }
335         
336         return 0;
337 }