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