Merge from trunk -r 25003:25745.
[blender.git] / source / blender / blenkernel / intern / 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) 2007 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
30 #include "MEM_guardedalloc.h"
31
32 #include "DNA_key_types.h"
33 #include "DNA_mesh_types.h"
34 #include "DNA_meshdata_types.h"
35 #include "DNA_modifier_types.h"
36 #include "DNA_object_types.h"
37 #include "DNA_scene_types.h"
38 #include "DNA_view3d_types.h"
39
40 #include "BLI_math.h"
41 #include "BLI_blenlib.h"
42 #include "BLI_pbvh.h"
43
44 #include "BKE_cdderivedmesh.h"
45 #include "BKE_customdata.h"
46 #include "BKE_depsgraph.h"
47 #include "BKE_DerivedMesh.h"
48 #include "BKE_global.h"
49 #include "BKE_mesh.h"
50 #include "BKE_modifier.h"
51 #include "BKE_multires.h"
52 #include "BKE_object.h"
53 #include "BKE_subsurf.h"
54 #include "BKE_utildefines.h"
55
56 #include "CCGSubSurf.h"
57
58 #include <math.h>
59 #include <string.h>
60
61 /* MULTIRES MODIFIER */
62 static const int multires_max_levels = 13;
63 static const int multires_grid_tot[] = {0, 4, 9, 25, 81, 289, 1089, 4225, 16641, 66049, 263169, 1050625, 4198401, 16785409};
64 static const int multires_side_tot[] = {0, 2, 3, 5,  9,  17,  33,   65,   129,   257,   513,    1025,    2049,    4097};
65
66 static void multires_mvert_to_ss(DerivedMesh *dm, MVert *mvert);
67 static void multiresModifier_disp_run(DerivedMesh *dm, Mesh *me, int invert, int add, DMGridData **oldGridData, int totlvl);
68
69 MultiresModifierData *find_multires_modifier(Object *ob)
70 {
71         ModifierData *md;
72         MultiresModifierData *mmd = NULL;
73
74         for(md = ob->modifiers.first; md; md = md->next) {
75                 if(md->type == eModifierType_Multires) {
76                         mmd = (MultiresModifierData*)md;
77                         break;
78                 }
79         }
80
81         return mmd;
82 }
83
84 static int multires_get_level(Object *ob, MultiresModifierData *mmd, int render)
85 {
86         if(render)
87                 return mmd->renderlvl;
88         else if(ob->mode == OB_MODE_SCULPT)
89                 return mmd->sculptlvl;
90         else
91                 return mmd->lvl;
92 }
93
94 static void multires_set_tot_level(Object *ob, MultiresModifierData *mmd, int lvl)
95 {
96         mmd->totlvl = lvl;
97
98         if(ob->mode != OB_MODE_SCULPT) {
99                 mmd->lvl = MAX2(mmd->lvl, lvl);
100                 CLAMP(mmd->lvl, 0, mmd->totlvl);
101         }
102
103         mmd->sculptlvl = MAX2(mmd->sculptlvl, lvl);
104         CLAMP(mmd->sculptlvl, 0, mmd->totlvl);
105
106         mmd->renderlvl = MAX2(mmd->renderlvl, lvl);
107         CLAMP(mmd->renderlvl, 0, mmd->totlvl);
108 }
109
110 static void multires_dm_mark_as_modified(DerivedMesh *dm)
111 {
112         CCGDerivedMesh *ccgdm = (CCGDerivedMesh*)dm;
113         ccgdm->multires.modified = 1;
114 }
115
116 void multires_mark_as_modified(Object *ob)
117 {
118         if(ob && ob->derivedFinal)
119                 multires_dm_mark_as_modified(ob->derivedFinal);
120 }
121
122 void multires_force_update(Object *ob)
123 {
124         if(ob && ob->derivedFinal) {
125                 ob->derivedFinal->needsFree =1;
126                 ob->derivedFinal->release(ob->derivedFinal);
127                 ob->derivedFinal = NULL;
128         }
129 }
130
131 /* XXX */
132 #if 0
133 void multiresModifier_join(Object *ob)
134 {
135         Base *base = NULL;
136         int highest_lvl = 0;
137
138         /* First find the highest level of subdivision */
139         base = FIRSTBASE;
140         while(base) {
141                 if(TESTBASELIB_BGMODE(v3d, scene, base) && base->object->type==OB_MESH) {
142                         ModifierData *md;
143                         for(md = base->object->modifiers.first; md; md = md->next) {
144                                 if(md->type == eModifierType_Multires) {
145                                         int totlvl = ((MultiresModifierData*)md)->totlvl;
146                                         if(totlvl > highest_lvl)
147                                                 highest_lvl = totlvl;
148
149                                         /* Ensure that all updates are processed */
150                                         multires_force_update(base->object);
151                                 }
152                         }
153                 }
154                 base = base->next;
155         }
156
157         /* No multires meshes selected */
158         if(highest_lvl == 0)
159                 return;
160
161         /* Subdivide all the displacements to the highest level */
162         base = FIRSTBASE;
163         while(base) {
164                 if(TESTBASELIB_BGMODE(v3d, scene, base) && base->object->type==OB_MESH) {
165                         ModifierData *md = NULL;
166                         MultiresModifierData *mmd = NULL;
167
168                         for(md = base->object->modifiers.first; md; md = md->next) {
169                                 if(md->type == eModifierType_Multires)
170                                         mmd = (MultiresModifierData*)md;
171                         }
172
173                         /* If the object didn't have multires enabled, give it a new modifier */
174                         if(!mmd) {
175                                 md = base->object->modifiers.first;
176                                 
177                                 while(md && modifierType_getInfo(md->type)->type == eModifierTypeType_OnlyDeform)
178                                         md = md->next;
179                                 
180                                 mmd = (MultiresModifierData*)modifier_new(eModifierType_Multires);
181                                 BLI_insertlinkbefore(&base->object->modifiers, md, mmd);
182                                 modifier_unique_name(&base->object->modifiers, mmd);
183                         }
184
185                         if(mmd)
186                                 multiresModifier_subdivide(mmd, base->object, highest_lvl - mmd->totlvl, 0, 0);
187                 }
188                 base = base->next;
189         }
190 }
191 #endif
192
193 /* Returns 1 on success, 0 if the src's totvert doesn't match */
194 int multiresModifier_reshape(MultiresModifierData *mmd, Object *dst, Object *src)
195 {
196         DerivedMesh *srcdm = src->derivedFinal;
197         DerivedMesh *mrdm = dst->derivedFinal;
198
199         if(mrdm && srcdm && mrdm->getNumVerts(mrdm) == srcdm->getNumVerts(srcdm)) {
200                 multires_mvert_to_ss(mrdm, srcdm->getVertArray(srcdm));
201
202                 multires_dm_mark_as_modified(mrdm);
203                 multires_force_update(dst);
204
205                 return 1;
206         }
207
208         return 0;
209 }
210
211 static void column_vectors_to_mat3(float mat[][3], float v1[3], float v2[3], float v3[3])
212 {
213         copy_v3_v3(mat[0], v1);
214         copy_v3_v3(mat[1], v2);
215         copy_v3_v3(mat[2], v3);
216 }
217
218 static void multires_copy_grid(float (*gridA)[3], float (*gridB)[3], int sizeA, int sizeB)
219 {
220         int x, y, j, skip;
221
222         if(sizeA > sizeB) {
223                 skip = (sizeA-1)/(sizeB-1);
224
225                 for(j = 0, y = 0; y < sizeB; y++)
226                         for(x = 0; x < sizeB; x++, j++)
227                                 copy_v3_v3(gridA[y*skip*sizeA + x*skip], gridB[j]);
228         }
229         else {
230                 skip = (sizeB-1)/(sizeA-1);
231
232                 for(j = 0, y = 0; y < sizeA; y++)
233                         for(x = 0; x < sizeA; x++, j++)
234                                 copy_v3_v3(gridA[j], gridB[y*skip*sizeB + x*skip]);
235         }
236 }
237
238 static void multires_copy_dm_grid(DMGridData *gridA, DMGridData *gridB, int sizeA, int sizeB)
239 {
240         int x, y, j, skip;
241
242         if(sizeA > sizeB) {
243                 skip = (sizeA-1)/(sizeB-1);
244
245                 for(j = 0, y = 0; y < sizeB; y++)
246                         for(x = 0; x < sizeB; x++, j++)
247                                 copy_v3_v3(gridA[y*skip*sizeA + x*skip].co, gridB[j].co);
248         }
249         else {
250                 skip = (sizeB-1)/(sizeA-1);
251
252                 for(j = 0, y = 0; y < sizeA; y++)
253                         for(x = 0; x < sizeA; x++, j++)
254                                 copy_v3_v3(gridA[j].co, gridB[y*skip*sizeB + x*skip].co);
255         }
256 }
257
258 /* direction=1 for delete higher, direction=0 for lower (not implemented yet) */
259 void multiresModifier_del_levels(MultiresModifierData *mmd, Object *ob, int direction)
260 {
261         Mesh *me = get_mesh(ob);
262         int lvl = multires_get_level(ob, mmd, 0);
263         int levels = mmd->totlvl - lvl;
264         MDisps *mdisps;
265
266         CustomData_external_read(&me->fdata, &me->id, CD_MASK_MDISPS, me->totface);
267         mdisps= CustomData_get_layer(&me->fdata, CD_MDISPS);
268
269         multires_force_update(ob);
270
271         if(mdisps && levels > 0 && direction == 1) {
272                 if(lvl > 0) {
273                         int nsize = multires_side_tot[lvl];
274                         int hsize = multires_side_tot[mmd->totlvl];
275                         int i;
276
277                         for(i = 0; i < me->totface; ++i) {
278                                 MDisps *mdisp= &mdisps[i];
279                                 float (*disps)[3], (*ndisps)[3], (*hdisps)[3];
280                                 int nvert = (me->mface[i].v4)? 4: 3;
281                                 int totdisp = multires_grid_tot[lvl]*nvert;
282                                 int S;
283
284                                 disps = MEM_callocN(sizeof(float) * 3 * totdisp, "multires disps");
285
286                                 ndisps = disps;
287                                 hdisps = mdisp->disps;
288
289                                 for(S = 0; S < nvert; S++) {
290                                         multires_copy_grid(ndisps, hdisps, nsize, hsize);
291
292                                         ndisps += nsize*nsize;
293                                         hdisps += hsize*hsize;
294                                 }
295
296                                 MEM_freeN(mdisp->disps);
297                                 mdisp->disps = disps;
298                                 mdisp->totdisp = totdisp;
299                         }
300                 }
301                 else {
302                         CustomData_external_remove(&me->fdata, &me->id, CD_MDISPS, me->totface);
303                         CustomData_free_layer_active(&me->fdata, CD_MDISPS, me->totface);
304                 }
305         }
306
307         multires_set_tot_level(ob, mmd, lvl);
308 }
309
310 static DerivedMesh *multires_dm_create_local(Object *ob, DerivedMesh *dm, int lvl, int totlvl, int simple)
311 {
312         MultiresModifierData mmd;
313
314         memset(&mmd, 0, sizeof(MultiresModifierData));
315         mmd.lvl = lvl;
316         mmd.sculptlvl = lvl;
317         mmd.renderlvl = lvl;
318         mmd.totlvl = totlvl;
319         mmd.simple = simple;
320
321         return multires_dm_create_from_derived(&mmd, 1, dm, ob, 0, 0);
322 }
323
324 static DerivedMesh *subsurf_dm_create_local(Object *ob, DerivedMesh *dm, int lvl, int simple, int optimal)
325 {
326         SubsurfModifierData smd;
327
328         memset(&smd, 0, sizeof(SubsurfModifierData));
329         smd.levels = smd.renderLevels = lvl;
330         smd.flags |= eSubsurfModifierFlag_SubsurfUv;
331         if(simple)
332                 smd.subdivType = ME_SIMPLE_SUBSURF;
333         if(optimal)
334                 smd.flags |= eSubsurfModifierFlag_ControlEdges;
335
336         return subsurf_make_derived_from_derived(dm, &smd, 0, NULL, 0, 0);
337 }
338
339 static void multires_reallocate_mdisps(Mesh *me, MDisps *mdisps, int lvl)
340 {
341         int i;
342
343         /* reallocate displacements to be filled in */
344         for(i = 0; i < me->totface; ++i) {
345                 int nvert = (me->mface[i].v4)? 4: 3;
346                 int totdisp = multires_grid_tot[lvl]*nvert;
347                 float (*disps)[3] = MEM_callocN(sizeof(float) * 3 * totdisp, "multires disps");
348
349                 if(mdisps[i].disps)
350                         MEM_freeN(mdisps[i].disps);
351
352                 mdisps[i].disps = disps;
353                 mdisps[i].totdisp = totdisp;
354         }
355 }
356
357 void multiresModifier_subdivide(MultiresModifierData *mmd, Object *ob, int updateblock, int simple)
358 {
359         Mesh *me = ob->data;
360         MDisps *mdisps;
361         int lvl= mmd->totlvl;
362         int totlvl= mmd->totlvl+1;
363
364         if(totlvl > multires_max_levels)
365                 return;
366
367         multires_force_update(ob);
368
369         mdisps = CustomData_get_layer(&me->fdata, CD_MDISPS);
370         if(!mdisps)
371                 mdisps = CustomData_add_layer(&me->fdata, CD_MDISPS, CD_DEFAULT, NULL, me->totface);
372
373         if(mdisps->disps && !updateblock && totlvl > 1) {
374                 /* upsample */
375                 DerivedMesh *lowdm, *cddm, *highdm;
376                 DMGridData **highGridData, **lowGridData, **subGridData;
377                 CCGSubSurf *ss;
378                 int i, numGrids, highGridSize, lowGridSize;
379
380                 /* create subsurf DM from original mesh at high level */
381                 cddm = CDDM_from_mesh(me, NULL);
382                 highdm = subsurf_dm_create_local(ob, cddm, totlvl, simple, 0);
383
384                 /* create multires DM from original mesh at low level */
385                 lowdm = multires_dm_create_local(ob, cddm, lvl, lvl, simple);
386                 cddm->release(cddm);
387
388                 /* copy subsurf grids and replace them with low displaced grids */
389                 numGrids = highdm->getNumGrids(highdm);
390                 highGridSize = highdm->getGridSize(highdm);
391                 highGridData = highdm->getGridData(highdm);
392                 lowGridSize = lowdm->getGridSize(lowdm);
393                 lowGridData = lowdm->getGridData(lowdm);
394
395                 subGridData = MEM_callocN(sizeof(float*)*numGrids, "subGridData*");
396
397                 for(i = 0; i < numGrids; ++i) {
398                         /* backup subsurf grids */
399                         subGridData[i] = MEM_callocN(sizeof(DMGridData)*highGridSize*highGridSize, "subGridData");
400                         memcpy(subGridData[i], highGridData[i], sizeof(DMGridData)*highGridSize*highGridSize);
401
402                         /* overwrite with current displaced grids */
403                         multires_copy_dm_grid(highGridData[i], lowGridData[i], highGridSize, lowGridSize);
404                 }
405
406                 /* low lower level dm no longer needed at this point */
407                 lowdm->release(lowdm);
408
409                 /* subsurf higher levels again with displaced data */
410                 ss= ((CCGDerivedMesh*)highdm)->ss;
411                 ccgSubSurf_updateFromFaces(ss, lvl, NULL, 0);
412                 ccgSubSurf_updateLevels(ss, lvl, NULL, 0);
413
414                 /* reallocate displacements */
415                 multires_reallocate_mdisps(me, mdisps, totlvl); 
416
417                 /* compute displacements */
418                 multiresModifier_disp_run(highdm, me, 1, 0, subGridData, totlvl);
419
420                 /* free */
421                 highdm->release(highdm);
422                 for(i = 0; i < numGrids; ++i)
423                         MEM_freeN(subGridData[i]);
424                 MEM_freeN(subGridData);
425         }
426         else {
427                 /* only reallocate, nothing to upsample */
428                 multires_reallocate_mdisps(me, mdisps, totlvl); 
429         }
430
431         multires_set_tot_level(ob, mmd, totlvl);
432 }
433
434 static void grid_tangent(int gridSize, int index, int x, int y, int axis, DMGridData **gridData, float t[3])
435 {
436         if(axis == 0) {
437                 if(x == gridSize - 1) {
438                         if(y == gridSize - 1)
439                                 sub_v3_v3v3(t, gridData[index][x + gridSize*(y - 1)].co, gridData[index][x - 1 + gridSize*(y - 1)].co);
440                         else
441                                 sub_v3_v3v3(t, gridData[index][x + gridSize*y].co, gridData[index][x - 1 + gridSize*y].co);
442                 }
443                 else
444                         sub_v3_v3v3(t, gridData[index][x + 1 + gridSize*y].co, gridData[index][x + gridSize*y].co);
445         }
446         else if(axis == 1) {
447                 if(y == gridSize - 1) {
448                         if(x == gridSize - 1)
449                                 sub_v3_v3v3(t, gridData[index][x - 1 + gridSize*y].co, gridData[index][x - 1 + gridSize*(y - 1)].co);
450                         else
451                                 sub_v3_v3v3(t, gridData[index][x + gridSize*y].co, gridData[index][x + gridSize*(y - 1)].co);
452                 }
453                 else
454                         sub_v3_v3v3(t, gridData[index][x + gridSize*(y + 1)].co, gridData[index][x + gridSize*y].co);
455         }
456 }
457
458 static void multiresModifier_disp_run(DerivedMesh *dm, Mesh *me, int invert, int add, DMGridData **oldGridData, int totlvl)
459 {
460         CCGDerivedMesh *ccgdm = (CCGDerivedMesh*)dm;
461         DMGridData **gridData, **subGridData;
462         MFace *mface = me->mface;
463         MDisps *mdisps = CustomData_get_layer(&me->fdata, CD_MDISPS);
464         int *gridOffset;
465         int i, numGrids, gridSize, dGridSize, dSkip;
466
467         if(!mdisps) {
468                 if(invert)
469                         mdisps = CustomData_add_layer(&me->fdata, CD_MDISPS, CD_DEFAULT, NULL, me->totface);
470                 else
471                         return;
472         }
473
474         numGrids = dm->getNumGrids(dm);
475         gridSize = dm->getGridSize(dm);
476         gridData = dm->getGridData(dm);
477         gridOffset = dm->getGridOffset(dm);
478         subGridData = (oldGridData)? oldGridData: gridData;
479
480         dGridSize = multires_side_tot[totlvl];
481         dSkip = (dGridSize-1)/(gridSize-1);
482
483         #pragma omp parallel for private(i) schedule(static)
484         for(i = 0; i < me->totface; ++i) {
485                 const int numVerts = mface[i].v4 ? 4 : 3;
486                 MDisps *mdisp = &mdisps[i];
487                 int S, x, y, gIndex = gridOffset[i];
488
489                 /* when adding new faces in edit mode, need to allocate disps */
490                 if(!mdisp->disps)
491                 #pragma omp critical
492                 {
493                         multires_reallocate_mdisps(me, mdisps, totlvl);
494                 }
495
496                 for(S = 0; S < numVerts; ++S, ++gIndex) {
497                         DMGridData *grid = gridData[gIndex];
498                         DMGridData *subgrid = subGridData[gIndex];
499                         float (*dispgrid)[3] = &mdisp->disps[S*dGridSize*dGridSize];
500
501                         for(y = 0; y < gridSize; y++) {
502                                 for(x = 0; x < gridSize; x++) {
503                                         float *co = grid[x + y*gridSize].co;
504                                         float *sco = subgrid[x + y*gridSize].co;
505                                         float *no = subgrid[x + y*gridSize].no;
506                                         float *data = dispgrid[dGridSize*y*dSkip + x*dSkip];
507                                         float mat[3][3], tx[3], ty[3], disp[3], d[3];
508
509                                         /* construct tangent space matrix */
510                                         grid_tangent(gridSize, gIndex, x, y, 0, subGridData, tx);
511                                         normalize_v3(tx);
512
513                                         grid_tangent(gridSize, gIndex, x, y, 1, subGridData, ty);
514                                         normalize_v3(ty);
515
516                                         //mul_v3_fl(tx, 1.0f/(gridSize-1));
517                                         //mul_v3_fl(ty, 1.0f/(gridSize-1));
518                                         //cross_v3_v3v3(no, tx, ty);
519
520                                         column_vectors_to_mat3(mat, tx, ty, no);
521
522                                         if(!invert) {
523                                                 /* convert to object space and add */
524                                                 mul_v3_m3v3(disp, mat, data);
525                                                 add_v3_v3v3(co, sco, disp);
526                                         }
527                                         else if(!add) {
528                                                 /* convert difference to tangent space */
529                                                 sub_v3_v3v3(disp, co, sco);
530                                                 invert_m3(mat);
531                                                 mul_v3_m3v3(data, mat, disp);
532                                         }
533                                         else {
534                                                 /* convert difference to tangent space */
535                                                 invert_m3(mat);
536                                                 mul_v3_m3v3(d, mat, co);
537                                                 add_v3_v3(data, d);
538                                         }
539                                 }
540                         }
541                 }
542         }
543
544         if(!invert) {
545                 ccgSubSurf_stitchFaces(ccgdm->ss, 0, NULL, 0);
546                 ccgSubSurf_updateNormals(ccgdm->ss, NULL, 0);
547         }
548 }
549
550 static void multiresModifier_update(DerivedMesh *dm)
551 {
552         CCGDerivedMesh *ccgdm= (CCGDerivedMesh*)dm;
553         Object *ob;
554         Mesh *me;
555         MDisps *mdisps;
556         MultiresModifierData *mmd;
557
558         ob = ccgdm->multires.ob;
559         me = ccgdm->multires.ob->data;
560         mmd = ccgdm->multires.mmd;
561         CustomData_external_read(&me->fdata, &me->id, CD_MASK_MDISPS, me->totface);
562         mdisps = CustomData_get_layer(&me->fdata, CD_MDISPS);
563
564         if(mdisps) {
565                 int lvl = ccgdm->multires.lvl;
566                 int totlvl = ccgdm->multires.totlvl;
567                 
568                 if(lvl < totlvl) {
569                         Mesh *me = ob->data;
570                         DerivedMesh *lowdm, *cddm, *highdm;
571                         DMGridData **highGridData, **lowGridData, **subGridData, **gridData, *diffGrid;
572                         CCGSubSurf *ss;
573                         int i, j, numGrids, highGridSize, lowGridSize;
574
575                         /* create subsurf DM from original mesh at high level */
576                         cddm = CDDM_from_mesh(me, NULL);
577                         highdm = subsurf_dm_create_local(ob, cddm, totlvl, mmd->simple, 0);
578
579                         /* create multires DM from original mesh and displacements */
580                         lowdm = multires_dm_create_local(ob, cddm, lvl, totlvl, mmd->simple);
581                         cddm->release(cddm);
582
583                         /* gather grid data */
584                         numGrids = highdm->getNumGrids(highdm);
585                         highGridSize = highdm->getGridSize(highdm);
586                         highGridData = highdm->getGridData(highdm);
587                         lowGridSize = lowdm->getGridSize(lowdm);
588                         lowGridData = lowdm->getGridData(lowdm);
589                         gridData = dm->getGridData(dm);
590
591                         subGridData = MEM_callocN(sizeof(DMGridData*)*numGrids, "subGridData*");
592                         diffGrid = MEM_callocN(sizeof(DMGridData)*lowGridSize*lowGridSize, "diff");
593
594                         for(i = 0; i < numGrids; ++i) {
595                                 /* backup subsurf grids */
596                                 subGridData[i] = MEM_callocN(sizeof(DMGridData)*highGridSize*highGridSize, "subGridData");
597                                 memcpy(subGridData[i], highGridData[i], sizeof(DMGridData)*highGridSize*highGridSize);
598
599                                 /* write difference of subsurf and displaced low level into high subsurf */
600                                 for(j = 0; j < lowGridSize*lowGridSize; ++j)
601                                         sub_v3_v3v3(diffGrid[j].co, gridData[i][j].co, lowGridData[i][j].co);
602
603                                 multires_copy_dm_grid(highGridData[i], diffGrid, highGridSize, lowGridSize);
604                         }
605
606                         /* lower level dm no longer needed at this point */
607                         MEM_freeN(diffGrid);
608                         lowdm->release(lowdm);
609
610                         /* subsurf higher levels again with difference of coordinates */
611                         ss= ((CCGDerivedMesh*)highdm)->ss;
612                         ccgSubSurf_updateFromFaces(ss, lvl, NULL, 0);
613                         ccgSubSurf_updateLevels(ss, lvl, NULL, 0);
614
615                         /* add to displacements */
616                         multiresModifier_disp_run(highdm, me, 1, 1, subGridData, mmd->totlvl);
617
618                         /* free */
619                         highdm->release(highdm);
620                         for(i = 0; i < numGrids; ++i)
621                                 MEM_freeN(subGridData[i]);
622                         MEM_freeN(subGridData);
623                 }
624                 else {
625                         DerivedMesh *cddm, *subdm;
626
627                         cddm = CDDM_from_mesh(me, NULL);
628                         subdm = subsurf_dm_create_local(ob, cddm, mmd->totlvl, mmd->simple, 0);
629                         cddm->release(cddm);
630
631                         multiresModifier_disp_run(dm, me, 1, 0, subdm->getGridData(subdm), mmd->totlvl);
632
633                         subdm->release(subdm);
634                 }
635         }
636 }
637
638 void multires_stitch_grids(Object *ob)
639 {
640         /* utility for smooth brush */
641         if(ob && ob->derivedFinal) {
642                 CCGDerivedMesh *ccgdm = (CCGDerivedMesh*)ob->derivedFinal;
643                 CCGFace **faces;
644                 int totface;
645
646                 if(ccgdm->pbvh) {
647                         BLI_pbvh_get_grid_updates(ccgdm->pbvh, 0, (void***)&faces, &totface);
648
649                         if(totface) {
650                                 ccgSubSurf_stitchFaces(ccgdm->ss, 0, faces, totface);
651                                 MEM_freeN(faces);
652                         }
653                 }
654         }
655 }
656
657 DerivedMesh *multires_dm_create_from_derived(MultiresModifierData *mmd, int local_mmd, DerivedMesh *dm, Object *ob,
658                                                     int useRenderParams, int isFinalCalc)
659 {
660         Mesh *me= ob->data;
661         DerivedMesh *result;
662         CCGDerivedMesh *ccgdm;
663         DMGridData **gridData, **subGridData;
664         int lvl= multires_get_level(ob, mmd, useRenderParams);
665         int i, gridSize, numGrids;
666
667         if(lvl == 0)
668                 return dm;
669
670         result = subsurf_dm_create_local(ob, dm, lvl,
671                 mmd->simple, mmd->flags & eMultiresModifierFlag_ControlEdges);
672
673         if(!local_mmd) {
674                 ccgdm = (CCGDerivedMesh*)result;
675
676                 ccgdm->multires.ob = ob;
677                 ccgdm->multires.mmd = mmd;
678                 ccgdm->multires.local_mmd = local_mmd;
679                 ccgdm->multires.lvl = lvl;
680                 ccgdm->multires.totlvl = mmd->totlvl;
681                 ccgdm->multires.modified = 0;
682                 ccgdm->multires.update = multiresModifier_update;
683         }
684
685         numGrids = result->getNumGrids(result);
686         gridSize = result->getGridSize(result);
687         gridData = result->getGridData(result);
688
689         subGridData = MEM_callocN(sizeof(DMGridData*)*numGrids, "subGridData*");
690
691         for(i = 0; i < numGrids; i++) {
692                 subGridData[i] = MEM_callocN(sizeof(DMGridData)*gridSize*gridSize, "subGridData");
693                 memcpy(subGridData[i], gridData[i], sizeof(DMGridData)*gridSize*gridSize);
694         }
695
696         CustomData_external_read(&me->fdata, &me->id, CD_MASK_MDISPS, me->totface);
697         multiresModifier_disp_run(result, ob->data, 0, 0, subGridData, mmd->totlvl);
698
699         for(i = 0; i < numGrids; i++)
700                 MEM_freeN(subGridData[i]);
701         MEM_freeN(subGridData);
702
703         return result;
704 }
705
706 /**** Old Multires code ****
707 ***************************/
708
709 /* Adapted from sculptmode.c */
710 static void old_mdisps_bilinear(float out[3], float (*disps)[3], int st, float u, float v)
711 {
712         int x, y, x2, y2;
713         const int st_max = st - 1;
714         float urat, vrat, uopp;
715         float d[4][3], d2[2][3];
716
717         if(u < 0)
718                 u = 0;
719         else if(u >= st)
720                 u = st_max;
721         if(v < 0)
722                 v = 0;
723         else if(v >= st)
724                 v = st_max;
725
726         x = floor(u);
727         y = floor(v);
728         x2 = x + 1;
729         y2 = y + 1;
730
731         if(x2 >= st) x2 = st_max;
732         if(y2 >= st) y2 = st_max;
733         
734         urat = u - x;
735         vrat = v - y;
736         uopp = 1 - urat;
737
738         mul_v3_v3fl(d[0], disps[y * st + x], uopp);
739         mul_v3_v3fl(d[1], disps[y * st + x2], urat);
740         mul_v3_v3fl(d[2], disps[y2 * st + x], uopp);
741         mul_v3_v3fl(d[3], disps[y2 * st + x2], urat);
742
743         add_v3_v3v3(d2[0], d[0], d[1]);
744         add_v3_v3v3(d2[1], d[2], d[3]);
745         mul_v3_fl(d2[0], 1 - vrat);
746         mul_v3_fl(d2[1], vrat);
747
748         add_v3_v3v3(out, d2[0], d2[1]);
749 }
750
751 static void old_mdisps_rotate(int S, int newside, int oldside, int x, int y, float *u, float *v)
752 {
753         float offset = oldside*0.5f - 0.5f;
754
755         if(S == 1) { *u= offset + x; *v = offset - y; }
756         if(S == 2) { *u= offset + y; *v = offset + x; }
757         if(S == 3) { *u= offset - x; *v = offset + y; }
758         if(S == 0) { *u= offset - y; *v = offset - x; }
759 }
760
761 static void old_mdisps_convert(MFace *mface, MDisps *mdisp)
762 {
763         int newlvl = log(sqrt(mdisp->totdisp)-1)/log(2);
764         int oldlvl = newlvl+1;
765         int oldside = multires_side_tot[oldlvl];
766         int newside = multires_side_tot[newlvl];
767         int nvert = (mface->v4)? 4: 3;
768         int newtotdisp = multires_grid_tot[newlvl]*nvert;
769         int x, y, S;
770         float (*disps)[3], (*out)[3], u, v;
771
772         disps = MEM_callocN(sizeof(float) * 3 * newtotdisp, "multires disps");
773
774         out = disps;
775         for(S = 0; S < nvert; S++) {
776                 for(y = 0; y < newside; ++y) {
777                         for(x = 0; x < newside; ++x, ++out) {
778                                 old_mdisps_rotate(S, newside, oldside, x, y, &u, &v);
779                                 old_mdisps_bilinear(*out, mdisp->disps, oldside, u, v);
780
781                                 if(S == 1) { (*out)[1]= -(*out)[1]; }
782                                 else if(S == 2) { SWAP(float, (*out)[0], (*out)[1]); }
783                                 else if(S == 3) { (*out)[0]= -(*out)[0]; }
784                                 else if(S == 0) { SWAP(float, (*out)[0], (*out)[1]); (*out)[0]= -(*out)[0]; (*out)[1]= -(*out)[1]; };
785                         }
786                 }
787         }
788
789         MEM_freeN(mdisp->disps);
790
791         mdisp->totdisp= newtotdisp;
792         mdisp->disps= disps;
793 }
794
795 void multires_load_old_250(Mesh *me)
796 {
797         MDisps *mdisps;
798         int a;
799
800         mdisps= CustomData_get_layer(&me->fdata, CD_MDISPS);
801
802         if(mdisps) {
803                 for(a=0; a<me->totface; a++)
804                         if(mdisps[a].totdisp)
805                                 old_mdisps_convert(&me->mface[a], &mdisps[a]);
806         }
807 }
808
809 /* Does not actually free lvl itself */
810 static void multires_free_level(MultiresLevel *lvl)
811 {
812         if(lvl) {
813                 if(lvl->faces) MEM_freeN(lvl->faces);
814                 if(lvl->edges) MEM_freeN(lvl->edges);
815                 if(lvl->colfaces) MEM_freeN(lvl->colfaces);
816         }
817 }
818
819 void multires_free(Multires *mr)
820 {
821         if(mr) {
822                 MultiresLevel* lvl= mr->levels.first;
823
824                 /* Free the first-level data */
825                 if(lvl) {
826                         CustomData_free(&mr->vdata, lvl->totvert);
827                         CustomData_free(&mr->fdata, lvl->totface);
828                         if(mr->edge_flags)
829                                 MEM_freeN(mr->edge_flags);
830                         if(mr->edge_creases)
831                                 MEM_freeN(mr->edge_creases);
832                 }
833
834                 while(lvl) {
835                         multires_free_level(lvl);                       
836                         lvl= lvl->next;
837                 }
838
839                 MEM_freeN(mr->verts);
840
841                 BLI_freelistN(&mr->levels);
842
843                 MEM_freeN(mr);
844         }
845 }
846
847 static void create_old_vert_face_map(ListBase **map, IndexNode **mem, const MultiresFace *mface,
848                                      const int totvert, const int totface)
849 {
850         int i,j;
851         IndexNode *node = NULL;
852         
853         (*map) = MEM_callocN(sizeof(ListBase) * totvert, "vert face map");
854         (*mem) = MEM_callocN(sizeof(IndexNode) * totface*4, "vert face map mem");
855         node = *mem;
856         
857         /* Find the users */
858         for(i = 0; i < totface; ++i){
859                 for(j = 0; j < (mface[i].v[3]?4:3); ++j, ++node) {
860                         node->index = i;
861                         BLI_addtail(&(*map)[mface[i].v[j]], node);
862                 }
863         }
864 }
865
866 static void create_old_vert_edge_map(ListBase **map, IndexNode **mem, const MultiresEdge *medge,
867                                      const int totvert, const int totedge)
868 {
869         int i,j;
870         IndexNode *node = NULL;
871         
872         (*map) = MEM_callocN(sizeof(ListBase) * totvert, "vert edge map");
873         (*mem) = MEM_callocN(sizeof(IndexNode) * totedge*2, "vert edge map mem");
874         node = *mem;
875         
876         /* Find the users */
877         for(i = 0; i < totedge; ++i){
878                 for(j = 0; j < 2; ++j, ++node) {
879                         node->index = i;
880                         BLI_addtail(&(*map)[medge[i].v[j]], node);
881                 }
882         }
883 }
884
885 static MultiresFace *find_old_face(ListBase *map, MultiresFace *faces, int v1, int v2, int v3, int v4)
886 {
887         IndexNode *n1;
888         int v[4] = {v1, v2, v3, v4}, i, j;
889
890         for(n1 = map[v1].first; n1; n1 = n1->next) {
891                 int fnd[4] = {0, 0, 0, 0};
892
893                 for(i = 0; i < 4; ++i) {
894                         for(j = 0; j < 4; ++j) {
895                                 if(v[i] == faces[n1->index].v[j])
896                                         fnd[i] = 1;
897                         }
898                 }
899
900                 if(fnd[0] && fnd[1] && fnd[2] && fnd[3])
901                         return &faces[n1->index];
902         }
903
904         return NULL;
905 }
906
907 static MultiresEdge *find_old_edge(ListBase *map, MultiresEdge *edges, int v1, int v2)
908 {
909         IndexNode *n1, *n2;
910
911         for(n1 = map[v1].first; n1; n1 = n1->next) {
912                 for(n2 = map[v2].first; n2; n2 = n2->next) {
913                         if(n1->index == n2->index)
914                                 return &edges[n1->index];
915                 }
916         }
917
918         return NULL;
919 }
920
921 static void multires_load_old_edges(ListBase **emap, MultiresLevel *lvl, int *vvmap, int dst, int v1, int v2, int mov)
922 {
923         int emid = find_old_edge(emap[2], lvl->edges, v1, v2)->mid;
924         vvmap[dst + mov] = emid;
925
926         if(lvl->next->next) {
927                 multires_load_old_edges(emap + 1, lvl->next, vvmap, dst + mov, v1, emid, mov / 2);
928                 multires_load_old_edges(emap + 1, lvl->next, vvmap, dst + mov, v2, emid, -mov / 2);
929         }
930 }
931
932 static void multires_load_old_faces(ListBase **fmap, ListBase **emap, MultiresLevel *lvl, int *vvmap, int dst,
933                                     int v1, int v2, int v3, int v4, int st2, int st3)
934 {
935         int fmid;
936         int emid13, emid14, emid23, emid24;
937
938         if(lvl && lvl->next) {
939                 fmid = find_old_face(fmap[1], lvl->faces, v1, v2, v3, v4)->mid;
940                 vvmap[dst] = fmid;
941
942                 emid13 = find_old_edge(emap[1], lvl->edges, v1, v3)->mid;
943                 emid14 = find_old_edge(emap[1], lvl->edges, v1, v4)->mid;
944                 emid23 = find_old_edge(emap[1], lvl->edges, v2, v3)->mid;
945                 emid24 = find_old_edge(emap[1], lvl->edges, v2, v4)->mid;
946
947
948                 multires_load_old_faces(fmap + 1, emap + 1, lvl->next, vvmap, dst + st2 * st3 + st3,
949                                         fmid, v2, emid23, emid24, st2, st3 / 2);
950
951                 multires_load_old_faces(fmap + 1, emap + 1, lvl->next, vvmap, dst - st2 * st3 + st3,
952                                         emid14, emid24, fmid, v4, st2, st3 / 2);
953
954                 multires_load_old_faces(fmap + 1, emap + 1, lvl->next, vvmap, dst + st2 * st3 - st3,
955                                         emid13, emid23, v3, fmid, st2, st3 / 2);
956
957                 multires_load_old_faces(fmap + 1, emap + 1, lvl->next, vvmap, dst - st2 * st3 - st3,
958                                         v1, fmid, emid13, emid14, st2, st3 / 2);
959
960                 if(lvl->next->next) {
961                         multires_load_old_edges(emap, lvl->next, vvmap, dst, emid24, fmid, st3);
962                         multires_load_old_edges(emap, lvl->next, vvmap, dst, emid13, fmid, -st3);
963                         multires_load_old_edges(emap, lvl->next, vvmap, dst, emid14, fmid, -st2 * st3);
964                         multires_load_old_edges(emap, lvl->next, vvmap, dst, emid23, fmid, st2 * st3);
965                 }
966         }
967 }
968
969 static void multires_mvert_to_ss(DerivedMesh *dm, MVert *mvert)
970 {
971         CCGDerivedMesh *ccgdm = (CCGDerivedMesh*) dm;
972         CCGSubSurf *ss = ccgdm->ss;
973         DMGridData *vd;
974         int index;
975         int totvert, totedge, totface;
976         int gridSize = ccgSubSurf_getGridSize(ss);
977         int edgeSize = ccgSubSurf_getEdgeSize(ss);
978         int i = 0;
979
980         totface = ccgSubSurf_getNumFaces(ss);
981         for(index = 0; index < totface; index++) {
982                 CCGFace *f = ccgdm->faceMap[index].face;
983                 int x, y, S, numVerts = ccgSubSurf_getFaceNumVerts(f);
984
985                 vd= ccgSubSurf_getFaceCenterData(f);
986                 copy_v3_v3(vd->co, mvert[i].co);
987                 i++;
988                 
989                 for(S = 0; S < numVerts; S++) {
990                         for(x = 1; x < gridSize - 1; x++, i++) {
991                                 vd= ccgSubSurf_getFaceGridEdgeData(ss, f, S, x);
992                                 copy_v3_v3(vd->co, mvert[i].co);
993                         }
994                 }
995
996                 for(S = 0; S < numVerts; S++) {
997                         for(y = 1; y < gridSize - 1; y++) {
998                                 for(x = 1; x < gridSize - 1; x++, i++) {
999                                         vd= ccgSubSurf_getFaceGridData(ss, f, S, x, y);
1000                                         copy_v3_v3(vd->co, mvert[i].co);
1001                                 }
1002                         }
1003                 }
1004         }
1005
1006         totedge = ccgSubSurf_getNumEdges(ss);
1007         for(index = 0; index < totedge; index++) {
1008                 CCGEdge *e = ccgdm->edgeMap[index].edge;
1009                 int x;
1010
1011                 for(x = 1; x < edgeSize - 1; x++, i++) {
1012                         vd= ccgSubSurf_getEdgeData(ss, e, x);
1013                         copy_v3_v3(vd->co, mvert[i].co);
1014                 }
1015         }
1016
1017         totvert = ccgSubSurf_getNumVerts(ss);
1018         for(index = 0; index < totvert; index++) {
1019                 CCGVert *v = ccgdm->vertMap[index].vert;
1020
1021                 vd= ccgSubSurf_getVertData(ss, v);
1022                 copy_v3_v3(vd->co, mvert[i].co);
1023                 i++;
1024         }
1025
1026         ccgSubSurf_updateToFaces(ss, 0, NULL, 0);
1027 }
1028
1029 /* Loads a multires object stored in the old Multires struct into the new format */
1030 static void multires_load_old_dm(DerivedMesh *dm, Mesh *me, int totlvl)
1031 {
1032         MultiresLevel *lvl, *lvl1;
1033         Multires *mr= me->mr;
1034         MVert *vsrc, *vdst;
1035         int src, dst;
1036         int st = multires_side_tot[totlvl - 1] - 1;
1037         int extedgelen = multires_side_tot[totlvl] - 2;
1038         int *vvmap; // inorder for dst, map to src
1039         int crossedgelen;
1040         int i, j, s, x, totvert, tottri, totquad;
1041
1042         src = 0;
1043         dst = 0;
1044         vsrc = mr->verts;
1045         vdst = dm->getVertArray(dm);
1046         totvert = dm->getNumVerts(dm);
1047         vvmap = MEM_callocN(sizeof(int) * totvert, "multires vvmap");
1048
1049         lvl1 = mr->levels.first;
1050         /* Load base verts */
1051         for(i = 0; i < lvl1->totvert; ++i) {
1052                 vvmap[totvert - lvl1->totvert + i] = src;
1053                 ++src;
1054         }
1055
1056         /* Original edges */
1057         dst = totvert - lvl1->totvert - extedgelen * lvl1->totedge;
1058         for(i = 0; i < lvl1->totedge; ++i) {
1059                 int ldst = dst + extedgelen * i;
1060                 int lsrc = src;
1061                 lvl = lvl1->next;
1062
1063                 for(j = 2; j <= mr->level_count; ++j) {
1064                         int base = multires_side_tot[totlvl - j + 1] - 2;
1065                         int skip = multires_side_tot[totlvl - j + 2] - 1;
1066                         int st = multires_side_tot[j - 1] - 1;
1067
1068                         for(x = 0; x < st; ++x)
1069                                 vvmap[ldst + base + x * skip] = lsrc + st * i + x;
1070
1071                         lsrc += lvl->totvert - lvl->prev->totvert;
1072                         lvl = lvl->next;
1073                 }
1074         }
1075
1076         /* Center points */
1077         dst = 0;
1078         for(i = 0; i < lvl1->totface; ++i) {
1079                 int sides = lvl1->faces[i].v[3] ? 4 : 3;
1080
1081                 vvmap[dst] = src + lvl1->totedge + i;
1082                 dst += 1 + sides * (st - 1) * st;
1083         }
1084
1085
1086         /* The rest is only for level 3 and up */
1087         if(lvl1->next && lvl1->next->next) {
1088                 ListBase **fmap, **emap;
1089                 IndexNode **fmem, **emem;
1090
1091                 /* Face edge cross */
1092                 tottri = totquad = 0;
1093                 crossedgelen = multires_side_tot[totlvl - 1] - 2;
1094                 dst = 0;
1095                 for(i = 0; i < lvl1->totface; ++i) {
1096                         int sides = lvl1->faces[i].v[3] ? 4 : 3;
1097
1098                         lvl = lvl1->next->next;
1099                         ++dst;
1100
1101                         for(j = 3; j <= mr->level_count; ++j) {
1102                                 int base = multires_side_tot[totlvl - j + 1] - 2;
1103                                 int skip = multires_side_tot[totlvl - j + 2] - 1;
1104                                 int st = pow(2, j - 2);
1105                                 int st2 = pow(2, j - 3);
1106                                 int lsrc = lvl->prev->totvert;
1107
1108                                 /* Skip exterior edge verts */
1109                                 lsrc += lvl1->totedge * st;
1110
1111                                 /* Skip earlier face edge crosses */
1112                                 lsrc += st2 * (tottri * 3 + totquad * 4);
1113
1114                                 for(s = 0; s < sides; ++s) {
1115                                         for(x = 0; x < st2; ++x) {
1116                                                 vvmap[dst + crossedgelen * (s + 1) - base - x * skip - 1] = lsrc;
1117                                                 ++lsrc;
1118                                         }
1119                                 }
1120
1121                                 lvl = lvl->next;
1122                         }
1123
1124                         dst += sides * (st - 1) * st;
1125
1126                         if(sides == 4) ++totquad;
1127                         else ++tottri;
1128
1129                 }
1130
1131                 /* calculate vert to edge/face maps for each level (except the last) */
1132                 fmap = MEM_callocN(sizeof(ListBase*) * (mr->level_count-1), "multires fmap");
1133                 emap = MEM_callocN(sizeof(ListBase*) * (mr->level_count-1), "multires emap");
1134                 fmem = MEM_callocN(sizeof(IndexNode*) * (mr->level_count-1), "multires fmem");
1135                 emem = MEM_callocN(sizeof(IndexNode*) * (mr->level_count-1), "multires emem");
1136                 lvl = lvl1;
1137                 for(i = 0; i < mr->level_count - 1; ++i) {
1138                         create_old_vert_face_map(fmap + i, fmem + i, lvl->faces, lvl->totvert, lvl->totface);
1139                         create_old_vert_edge_map(emap + i, emem + i, lvl->edges, lvl->totvert, lvl->totedge);
1140                         lvl = lvl->next;
1141                 }
1142
1143                 /* Interior face verts */
1144                 lvl = lvl1->next->next;
1145                 dst = 0;
1146                 for(j = 0; j < lvl1->totface; ++j) {
1147                         int sides = lvl1->faces[j].v[3] ? 4 : 3;
1148                         int ldst = dst + 1 + sides * (st - 1);
1149
1150                         for(s = 0; s < sides; ++s) {
1151                                 int st2 = multires_side_tot[totlvl - 1] - 2;
1152                                 int st3 = multires_side_tot[totlvl - 2] - 2;
1153                                 int st4 = st3 == 0 ? 1 : (st3 + 1) / 2;
1154                                 int mid = ldst + st2 * st3 + st3;
1155                                 int cv = lvl1->faces[j].v[s];
1156                                 int nv = lvl1->faces[j].v[s == sides - 1 ? 0 : s + 1];
1157                                 int pv = lvl1->faces[j].v[s == 0 ? sides - 1 : s - 1];
1158
1159                                 multires_load_old_faces(fmap, emap, lvl1->next, vvmap, mid,
1160                                                         vvmap[dst], cv,
1161                                                         find_old_edge(emap[0], lvl1->edges, pv, cv)->mid,
1162                                                         find_old_edge(emap[0], lvl1->edges, cv, nv)->mid,
1163                                                         st2, st4);
1164
1165                                 ldst += (st - 1) * (st - 1);
1166                         }
1167
1168
1169                         dst = ldst;
1170                 }
1171
1172                 lvl = lvl->next;
1173
1174                 for(i = 0; i < mr->level_count - 1; ++i) {
1175                         MEM_freeN(fmap[i]);
1176                         MEM_freeN(fmem[i]);
1177                         MEM_freeN(emap[i]);
1178                         MEM_freeN(emem[i]);
1179                 }
1180
1181                 MEM_freeN(fmap);
1182                 MEM_freeN(emap);
1183                 MEM_freeN(fmem);
1184                 MEM_freeN(emem);
1185         }
1186
1187         /* Transfer verts */
1188         for(i = 0; i < totvert; ++i)
1189                 copy_v3_v3(vdst[i].co, vsrc[vvmap[i]].co);
1190
1191         MEM_freeN(vvmap);
1192
1193         multires_mvert_to_ss(dm, vdst);
1194 }
1195
1196
1197 void multires_load_old(Object *ob, Mesh *me)
1198 {
1199         MultiresLevel *lvl;
1200         ModifierData *md;
1201         MultiresModifierData *mmd;
1202         DerivedMesh *dm, *orig;
1203         int i;
1204
1205         /* Load original level into the mesh */
1206         lvl = me->mr->levels.first;
1207         CustomData_free_layers(&me->vdata, CD_MVERT, lvl->totvert);
1208         CustomData_free_layers(&me->edata, CD_MEDGE, lvl->totedge);
1209         CustomData_free_layers(&me->fdata, CD_MFACE, lvl->totface);
1210         me->totvert = lvl->totvert;
1211         me->totedge = lvl->totedge;
1212         me->totface = lvl->totface;
1213         me->mvert = CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, NULL, me->totvert);
1214         me->medge = CustomData_add_layer(&me->edata, CD_MEDGE, CD_CALLOC, NULL, me->totedge);
1215         me->mface = CustomData_add_layer(&me->fdata, CD_MFACE, CD_CALLOC, NULL, me->totface);
1216         memcpy(me->mvert, me->mr->verts, sizeof(MVert) * me->totvert);
1217         for(i = 0; i < me->totedge; ++i) {
1218                 me->medge[i].v1 = lvl->edges[i].v[0];
1219                 me->medge[i].v2 = lvl->edges[i].v[1];
1220         }
1221         for(i = 0; i < me->totface; ++i) {
1222                 me->mface[i].v1 = lvl->faces[i].v[0];
1223                 me->mface[i].v2 = lvl->faces[i].v[1];
1224                 me->mface[i].v3 = lvl->faces[i].v[2];
1225                 me->mface[i].v4 = lvl->faces[i].v[3];
1226         }
1227
1228         /* Add a multires modifier to the object */
1229         md = ob->modifiers.first;
1230         while(md && modifierType_getInfo(md->type)->type == eModifierTypeType_OnlyDeform)
1231                 md = md->next;                          
1232         mmd = (MultiresModifierData*)modifier_new(eModifierType_Multires);
1233         BLI_insertlinkbefore(&ob->modifiers, md, mmd);
1234
1235         for(i = 0; i < me->mr->level_count - 1; ++i)
1236                 multiresModifier_subdivide(mmd, ob, 1, 0);
1237
1238         mmd->lvl = mmd->totlvl;
1239         orig = CDDM_from_mesh(me, NULL);
1240         dm = multires_dm_create_from_derived(mmd, 0, orig, ob, 0, 0);
1241                                            
1242         multires_load_old_dm(dm, me, mmd->totlvl+1);
1243
1244         multires_dm_mark_as_modified(dm);
1245         dm->release(dm);
1246         orig->release(orig);
1247
1248         /* Remove the old multires */
1249         multires_free(me->mr);
1250         me->mr= NULL;
1251 }
1252