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